opencensus-stackdriver 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de5d4705ab7b4fa7150e3b561d6f9c13767ac11421cb5a0c46d1fa0d74b1d755
-  data.tar.gz: e01dec6e909b19e2eddbecc0fa325b0d57c8218ac62dbab45c11b025d628d941
+  metadata.gz: fccacbc5dbd93388ade17c168d77b0a31cd0369b952b27fa1cb4fbc707f21c01
+  data.tar.gz: 12a2e44508d7b3ee0a74e126931be8e1775bc3ee7e1e3473082291de1ae5240b
 SHA512:
-  metadata.gz: 3dca3bcb5eb051ff45c181946e29e7a68e3a961ac818129c8de72dd83cae673a435878e4089a6875e57408b9a344a4c47bee0eac1a8d8d51e900a73d9a2237df
-  data.tar.gz: 65d28205b8301f9a7b9e074428e5ba4e44c4380303762e8fb2f17219b7ef0985f494801dff38a6fb87b2899573795f1f6ffac3c5ae3ffb9ffa1055dd0ed2c650
+  metadata.gz: 885148fe5c54cca14e707a2ba774b9d1fa41df6e9f051ca106643149122f02f12e76ba53dec10b380f6662aa2b85ccbe28b7aa1687f7500925a41bc129180457
+  data.tar.gz: fc1572aa7fee3656ccc05632cd668efca389208bbcc6c0228907cd63e217a8ac1ecddc6efc9b0597268e6046f845de24180397d3500336c36b56e6347f753fdf

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Release History
 
+### 0.3.0 / 2019-10-14
+
+This release requires version 0.5 or later of the opencensus gem. It includes
+experimental support for exporting OpenCensus Stats to the Stackdriver
+Monitoring service. Note that Stats support is incomplete and there are known
+issues.
+
 ### 0.2.0 / 2018-10-22
 
 This release requires version 0.4 or later of the opencensus gem.

data/README.md

@@ -8,7 +8,8 @@ that exports data to [Stackdriver](https://cloud.google.com/stackdriver/).
 OpenCensus is a platform- and provider-agnostic framework for distributed
 tracing and stats collection. For more information, see https://opencensus.io.
 
-This library is in an alpha stage, and the API is subject to change.
+This library is in an alpha stage, and the API is subject to change. In
+particular, support for the Stats API is currently incomplete and experimental.
 
 ## Quick Start
 

data/lib/opencensus/stackdriver.rb

@@ -21,7 +21,8 @@ module OpenCensus
   # stats information to Stackdriver Trace and Monitoring services.
   #
   # The Stackdriver Trace plugin for OpenCensus is implemented in the
-  # {OpenCensus::Trace::Exporters::Stackdriver} class.
+  # {OpenCensus::Trace::Exporters::Stackdriver} class and
+  # {OpenCensus::Stats::Exporters::Stackdriver}
   #
   module Stackdriver
   end
@@ -30,3 +31,5 @@ end
 require "opencensus/stackdriver/version"
 require "opencensus/trace/exporters/stackdriver"
 require "opencensus/trace/exporters/stackdriver/converter"
+require "opencensus/stats/exporters/stackdriver"
+require "opencensus/stats/exporters/stackdriver/converter"

data/lib/opencensus/stackdriver/version.rb

@@ -16,6 +16,6 @@
 module OpenCensus
   module Stackdriver
     ## Current OpenCensus Stackdriver plugin version
-    VERSION = "0.2.0".freeze
+    VERSION = "0.3.0".freeze
   end
 end

data/lib/opencensus/stats/exporters/stackdriver.rb

@@ -0,0 +1,338 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+gem "google-cloud-monitoring"
+gem "concurrent-ruby"
+
+require "concurrent"
+require "google/cloud/monitoring"
+require "google/cloud/monitoring/v3"
+
+module OpenCensus
+  ##
+  # OpenCensus Stats provides a standard interface for distributed stats
+  # recording.
+  #
+  module Stats
+    ##
+    # The exporters module is a namespace for stats exporters.
+    #
+    module Exporters
+      ##
+      # The Stackdriver exporter for OpenCensus Stats exports captured stats
+      # to a Google Monitoring project. It calls the Monitoring API in
+      # a background thread pool.
+      #
+      class Stackdriver
+        # Default custom opencensus domain name
+        # @return [String]
+        CUSTOM_OPENCENSUS_DOMAIN = "custom.googleapis.com/opencensus".freeze
+
+        # Default metric resouce type.
+        # @return [String]
+        GLOBAL_RESOURCE_TYPE = "global".freeze
+
+        # The project ID
+        # @return [String]
+        #
+        attr_reader :project_id
+
+        # Metric prefix
+        # @return [String]
+        attr_reader :metric_prefix
+
+        # Metric resource type
+        # @return [String]
+        attr_reader :resource_type
+
+        # Metric resource labels
+        # @return [Hash<String,String>]
+        attr_reader :resource_labels
+
+        # Create a Stackdriver exporter.
+        #
+        # @param [String] project_id The project identifier for the Stackdriver
+        #     Monitoring service you are connecting to. If you are running on
+        #     Google
+        #     Cloud hosting (e.g. Compute Engine, Kubernetes Engine, or App
+        #     Engine), this parameter is optional and will default to the
+        #     hosting project. Otherwise, it is required.
+        # @param [String, Hash, Google::Auth::Credentials] credentials The
+        #     Stackdriver API credentials, which can be a path to a keyfile as
+        #     a String, the contents of a keyfile as a Hash, or a
+        #     Google::Auth::Credentials object. If you are running on Google
+        #     Cloud hosting (e.g. Compute Engine, Kubernetes Engine, or App
+        #     Engine), this parameter is optional and will default to the
+        #     credentials provided by the hosting project. Otherwise, it is
+        #     required.
+        # @param [String, Array<String>] scope The OAuth 2.0 scopes controlling
+        #     the set of resources and operations the API client can access.
+        #     Optional. Most applications can leave this set to the default.
+        # @param [Integer] timeout The default timeout for API requests, in
+        #     seconds. Optional.
+        # @param [Hash] client_config An optional set of additional
+        #     configuration values for the API connection.
+        # @param [Integer] max_queue The maximum number of API requests that
+        #     can be queued for background operation. If the queue exceeds this
+        #     value, additional requests will be run in the calling thread
+        #     rather than in the background. Set to 0 to allow the queue to
+        #     grow indefinitely. Default is 1000.
+        # @param [Integer] max_threads The maximum number of threads that can
+        #     be spun up to handle API requests. Default is 1. If set to 0,
+        #     backgrounding will be disabled and all requests will run in the
+        #     calling thread.
+        # @param [Integer] auto_terminate_time The time in seconds allotted to
+        #     complete any pending background requests when Ruby is exiting.
+        # @param [String] metric_prefix Prefix for stackdriver metric.
+        #   Default value set to {CUSTOM_OPENCENSUS_DOMAIN}
+        # @param [String] resource_type Metric resource type.
+        #   Default value set to {GLOBAL_RESOURCE_TYPE}
+        # @param [Hash<String,String>] resource_labels Metric resource labels.
+        #   Default value set to { "project_id" => project_id }
+        #
+        def initialize \
+            project_id: nil,
+            credentials: nil,
+            scope: nil,
+            timeout: nil,
+            client_config: nil,
+            max_queue: 1000,
+            max_threads: 1,
+            auto_terminate_time: 10,
+            mock_client: nil,
+            metric_prefix: nil,
+            resource_type: nil,
+            resource_labels: nil
+          @project_id = final_project_id project_id
+          @metric_prefix = metric_prefix || CUSTOM_OPENCENSUS_DOMAIN
+          @resource_type = resource_type || GLOBAL_RESOURCE_TYPE
+          @resource_labels = resource_labels || {
+            "project_id" => @project_id
+          }
+          @executor = create_executor max_threads, max_queue
+
+          if auto_terminate_time
+            terminate_at_exit! @executor, auto_terminate_time
+          end
+
+          if mock_client
+            @client_promise =
+              Concurrent::Promise.fulfill mock_client, executor: @executor
+          else
+            credentials = final_credentials credentials, scope
+            @client_promise = create_client_promise \
+              @executor, credentials, scope, client_config, timeout
+          end
+
+          @converter = Converter.new @project_id
+          @project_path = Google::Cloud::Monitoring::V3:: \
+            MetricServiceClient.project_path @project_id
+        end
+
+        # Export stats to Monitoring service asynchronously.
+        #
+        # @param [Array<OpenCensus::Stats::ViewData>] views_data The captured
+        #   stats data
+        #
+        def export views_data
+          raise "Exporter is no longer running" unless @executor.running?
+
+          return if views_data.nil? || views_data.empty?
+
+          @client_promise.execute
+          export_promise = @client_promise.then do |client|
+            export_as_batch(client, views_data)
+          end
+          export_promise.on_error do |reason|
+            warn "Unable to export to Monitering service because: #{reason}"
+          end
+
+          nil
+        end
+
+        ##
+        # Returns true if this exporter is running and will accept further
+        # export requests. Returns false once the exporter begins shutting down.
+        #
+        # @return [boolean]
+        #
+        def running?
+          @executor.running?
+        end
+
+        ##
+        # Returns true if this exporter has finished shutting down and all
+        # pending stats have been sent.
+        #
+        # @return [boolean]
+        #
+        def shutdown?
+          @executor.shutdown?
+        end
+
+        ##
+        # Returns true if this exporter has begun shutting down and is no
+        # longer accepting export requests, but is still running queued
+        # requests in the background.
+        #
+        # @return [boolean]
+        #
+        def shuttingdown?
+          @executor.shuttingdown?
+        end
+
+        ##
+        # Begin shutting down the exporter gracefully. After this operation is
+        # performed, the exporter will no longer accept export requests, but
+        # will finish any pending requests in the background.
+        #
+        def shutdown
+          @executor.shutdown
+          self
+        end
+
+        ##
+        # Begin shutting down the exporter forcefully. After this operation is
+        # performed, the exporter will no longer accept export requests, and
+        # will finish any currently running export requests, but will cancel
+        # all requests that are still pending in the queue.
+        #
+        def kill
+          @executor.kill
+          self
+        end
+
+        ##
+        # Wait for the exporter to finish shutting down.
+        #
+        # @param [Integer, nil] timeout A timeout in seconds, or nil for no
+        #     timeout.
+        # @return [boolean] true if the exporter is shut down, or false if the
+        #     wait timed out.
+        #
+        def wait_for_termination timeout = nil
+          @executor.wait_for_termination timeout
+        end
+
+        # Create a metric descriptor
+        #
+        # An error will be raised if there is
+        # already a metric descriptor created with the same name
+        # but it has a different aggregation or keys.
+        #
+        # @param [OpenCensus::Stats::View] view
+        # @return [Google::Api::MetricDescriptor]
+        #
+        def create_metric_descriptor view
+          metric_descriptor = @converter.convert_metric_descriptor(
+            view,
+            metric_prefix
+          )
+          metric_name = Google::Cloud::Monitoring::V3:: \
+            MetricServiceClient.metric_descriptor_path(
+              project_id,
+              metric_descriptor.type
+            )
+
+          @client_promise.execute
+          descriptor_create_promise = @client_promise.then do |client|
+            client.create_metric_descriptor metric_name, metric_descriptor
+          end
+          descriptor_create_promise.value!
+        end
+
+        private
+
+        # Create the executor
+        def create_executor max_threads, max_queue
+          if max_threads >= 1
+            Concurrent::ThreadPoolExecutor.new \
+              min_threads: 1, max_threads: max_threads,
+              max_queue: max_queue, fallback_policy: :caller_runs,
+              auto_terminate: false
+          else
+            Concurrent::ImmediateExecutor.new
+          end
+        end
+
+        # Create the client promise.
+        # We create the client lazily so grpc doesn't get initialized until
+        # we actually need it. This is important because if it is intialized
+        # too early, before a fork, it can go into a bad state.
+        def create_client_promise executor, credentials, scopes, client_config,
+                                  timeout
+          Concurrent::Promise.new executor: executor do
+            Google::Cloud::Monitoring::Metric.new(
+              credentials: credentials,
+              scopes: scopes,
+              client_config: client_config,
+              timeout: timeout,
+              lib_name: "opencensus",
+              lib_version: OpenCensus::Stackdriver::VERSION
+            )
+          end
+        end
+
+        # Set up an at_exit hook that shuts the exporter down.
+        def terminate_at_exit! executor, timeout
+          at_exit do
+            executor.shutdown
+            unless executor.wait_for_termination timeout
+              executor.kill
+              executor.wait_for_termination timeout
+            end
+          end
+        end
+
+        # Fall back to default project ID
+        def final_project_id project_id
+          project_id ||
+            Google::Cloud.configure.project_id ||
+            Google::Cloud.env.project_id
+        end
+
+        # Fall back to default credentials, and wrap in a creds object
+        def final_credentials credentials, scope
+          credentials ||=
+            Google::Cloud.configure.credentials ||
+            Google::Cloud::Monitoring::V3::Credentials.default(scope: scope)
+          unless credentials.is_a? Google::Auth::Credentials
+            credentials = Google::Cloud::Monitoring::V3::Credentials.new(
+              credentials,
+              scope: scope
+            )
+          end
+          credentials
+        end
+
+        # Export a list of stats in the current thread
+        def export_as_batch client, views_data
+          time_series = views_data.map do |view_data|
+            @converter.convert_time_series(
+              metric_prefix,
+              resource_type,
+              resource_labels,
+              view_data
+            )
+          end
+
+          client.create_time_series @project_path, time_series.flatten!
+        end
+      end
+    end
+  end
+end

data/lib/opencensus/stats/exporters/stackdriver/converter.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+module OpenCensus
+  module Stats
+    module Exporters
+      class Stackdriver
+        ##
+        # An object that converts OpenCensus stats data objects to Monitoring
+        # service protos
+        #
+        # @private
+        #
+        class Converter
+          ##
+          # Create a converter
+          #
+          # @param [String] project_id Google project ID
+          #
+          def initialize project_id
+            @project_id = project_id
+          end
+
+          # Convert view to metric descriptor
+          #
+          # @param [OpenCensus::Stats:View] view Stats view
+          # @param [String] metric_prefix Metric prefix name
+          # @return [Google::Api::MetricDescriptor]
+          #
+          def convert_metric_descriptor view, metric_prefix
+            descriptor = Google::Api::MetricDescriptor.new(
+              type: make_metric_type(metric_prefix, view.name),
+              display_name: view.measure.name,
+              metric_kind: convert_metric_kind(view.aggregation),
+              value_type: convert_metric_value_type(view),
+              unit: view.measure.unit,
+              labels: convert_labels(view.columns)
+            )
+
+            descriptor.description = view.description if view.description
+            descriptor
+          end
+
+          # Conver to lables
+          #
+          # @param [Array<String>] names
+          # @return [Array<Google::Api::LabelDescriptor>]
+          def convert_labels names
+            names.map do |name|
+              Google::Api::LabelDescriptor.new(
+                key: name,
+                value_type: Google::Api::LabelDescriptor::ValueType::STRING
+              )
+            end
+          end
+
+          # Convert to metric view type.
+          #
+          # @param [OpenCensus::Stats:View] view Stats view
+          # @return [Symbol] Metric value type
+          #
+          def convert_metric_value_type view
+            case view.aggregation
+            when OpenCensus::Stats::Aggregation::Distribution
+              Google::Api::MetricDescriptor::ValueType::DISTRIBUTION
+            when OpenCensus::Stats::Aggregation::Count
+              Google::Api::MetricDescriptor::ValueType::INT64
+            when OpenCensus::Stats::Aggregation::Sum,
+                OpenCensus::Stats::Aggregation::LastValue
+              if view.measure.int64?
+                Google::Api::MetricDescriptor::ValueType::INT64
+              else
+                Google::Api::MetricDescriptor::ValueType::DOUBLE
+              end
+            end
+          end
+
+          # Convert to metric kind
+          #
+          # @param [OpenCensus::Stats:Aggregation::LastValue,
+          #   OpenCensus::Stats:Aggregation::Sum,
+          #   OpenCensus::Stats:Aggregation::Count,
+          #   OpenCensus::Stats:Aggregation::Distribution] aggregation
+          #   Aggregation type
+          # @return [Symbol] Metric kind type
+          #
+          def convert_metric_kind aggregation
+            last_value_class = OpenCensus::Stats::Aggregation::LastValue
+
+            if aggregation.instance_of? last_value_class
+              return Google::Api::MetricDescriptor::MetricKind::GAUGE
+            end
+
+            Google::Api::MetricDescriptor::MetricKind::CUMULATIVE
+          end
+
+          # Convert view data to time series list
+          #
+          # @param [String] metric_prefix Metric prefix name
+          # @param [String] resource_type Metric resource type
+          # @param [Hash<String,String>] resource_labels Metric resource labels
+          # @param [OpenCensus::Stats::ViewData] view_data Stats view data
+          # @return [Array[Google::Monitoring::V3::TimeSeries]]
+          #
+          def convert_time_series metric_prefix, resource_type, resource_labels,
+                                  view_data
+            view = view_data.view
+
+            view_data.data.map do |tag_values, aggr_data|
+              series = Google::Monitoring::V3::TimeSeries.new(
+                metric: {
+                  type: make_metric_type(metric_prefix, view.name),
+                  labels: Hash[view.columns.zip tag_values]
+                },
+                resource: {
+                  type: resource_type,
+                  labels: resource_labels
+                },
+                metric_kind: convert_metric_kind(view.aggregation),
+                value_type: convert_metric_value_type(view)
+              )
+
+              series.points << convert_point(
+                view_data.start_time,
+                aggr_data.time,
+                view.measure,
+                aggr_data
+              )
+
+              series
+            end
+          end
+
+          # Convert aggr data to time series point proto
+          #
+          # @param [Time] start_time Start time
+          # @param [Time] end_time Start time
+          # @param [OpenCensus::Stats:Measure] measure Measure details
+          # @param [OpenCensus::Stats:AggregationData] aggr_data Aggregated data
+          # @raise [TypeError] If invalid aggr data type.
+          # @return [Google::Monitoring::V3::Point]
+          def convert_point start_time, end_time, measure, aggr_data
+            case aggr_data
+            when OpenCensus::Stats::AggregationData::Distribution
+              create_distribution_point start_time, end_time, aggr_data
+            when OpenCensus::Stats::AggregationData::LastValue
+              create_number_point(
+                start_time,
+                start_time,
+                aggr_data.value,
+                measure
+              )
+            when OpenCensus::Stats::AggregationData::Sum,
+                OpenCensus::Stats::AggregationData::Count
+              create_number_point(
+                start_time,
+                end_time,
+                aggr_data.value,
+                measure
+              )
+            else
+              raise TypeError, "invalid aggregation type : #{aggr_data.class}"
+            end
+          end
+
+          # Create a distribution point
+          # @param [Time] start_time Start time
+          # @param [Time] end_time Start time
+          # @param [OpenCensus::Stats::AggregationData::Distribution] aggr_data
+          # @return [Google::Monitoring::V3::Point]
+          #
+          def create_distribution_point start_time, end_time, aggr_data
+            value = {
+              count: aggr_data.count,
+              mean: aggr_data.mean,
+              sum_of_squared_deviation: aggr_data.sum_of_squared_deviation,
+              bucket_options: {
+                explicit_buckets: {
+                  bounds: [0].concat(aggr_data.buckets)
+                }
+              },
+              bucket_counts: [0].concat(aggr_data.bucket_counts)
+            }
+
+            Google::Monitoring::V3::Point.new(
+              interval: {
+                start_time: convert_time(start_time),
+                end_time: convert_time(end_time)
+              },
+              value: {
+                distribution_value: value
+              }
+            )
+          end
+
+          # Create a number point
+          # @param [Time] start_time Start time
+          # @param [Time] end_time Start time
+          # @param [Integer, Float] value
+          # @param [OpenCensus::Stats::Measure] measure Measure defination
+          # @return [Google::Monitoring::V3::Point]
+          #
+          def create_number_point start_time, end_time, value, measure
+            value = if measure.int64?
+                      { int64_value: value }
+                    else
+                      { double_value: value }
+                    end
+
+            Google::Monitoring::V3::Point.new(
+              interval: {
+                start_time: convert_time(start_time),
+                end_time: convert_time(end_time)
+              },
+              value: value
+            )
+          end
+
+          # Convert time object to protobuf timestamp
+          #
+          # @param [Time] time Ruby Time object
+          # @return [Google::Protobuf::Timestamp] The generated proto
+          #
+          def convert_time time
+            proto = Google::Protobuf::Timestamp.new
+            proto.from_time(time)
+            proto
+          end
+
+          ##
+          # Make make metric type
+          #
+          # @param [String] metric_prefix The metric prefix
+          # @param [String] name The name of the mertic view
+          # @return [String] The metric type path
+          #
+          def make_metric_type metric_prefix, name
+            "#{metric_prefix}/#{name}"
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opencensus-stackdriver
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Daniel Azuma
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-23 00:00:00.000000000 Z
+date: 2019-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -44,28 +44,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.5'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: google-cloud-monitoring
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
-  type: :development
+        version: 0.29.2
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: 0.29.2
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.17'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
@@ -195,6 +209,8 @@ files:
 - lib/opencensus-stackdriver.rb
 - lib/opencensus/stackdriver.rb
 - lib/opencensus/stackdriver/version.rb
+- lib/opencensus/stats/exporters/stackdriver.rb
+- lib/opencensus/stats/exporters/stackdriver/converter.rb
 - lib/opencensus/trace/exporters/stackdriver.rb
 - lib/opencensus/trace/exporters/stackdriver/converter.rb
 homepage: https://github.com/census-instrumentation/ruby-stackdriver-exporter
@@ -216,8 +232,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Stackdriver exporter for OpenCensus