graphql-hive 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 63bc735d6516da78a9f7cab670defd21e68a8295132dba4f871d0b4fa6f8b944
+  data.tar.gz: df3580ad1ebabd31c5ec3960811c1d4defc1702c020c1152ee029ac2879574cc
+SHA512:
+  metadata.gz: 0624adc8d88ef8ef468ec08b4fa9a0c3f375bd35a2a700dac3a4bca22631c1f88aec175405d598210b48d330c145a878af11188dc396c45f52dd1706bb99b784
+  data.tar.gz: 7c2cc7f8327471969eb9512e5ab4550f9f9093042a930fe1c497adf2958c01f868f468ed6aac3ec2def5d750b5352e7543dc9c1168e0d049a89134939460476f

data/.github/workflows/ci.yml

@@ -0,0 +1,27 @@
+name: CI
+on:
+  - pull_request
+
+jobs:
+  rubocop:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - uses: ruby/setup-ruby@359bebbc29cbe6c87da6bc9ea3bc930432750108
+      with:
+        ruby-version: 2.6
+        bundler-cache: true
+    - run: bundle exec rake rubocop
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby-version: ['3.1', '3.0', '2.7', '2.6']
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - uses: ruby/setup-ruby@359bebbc29cbe6c87da6bc9ea3bc930432750108
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true
+    - run: bundle exec rake spec

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+graphql-hive-0.1.0.gem

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,37 @@
+AllCops:
+  TargetRubyVersion: 2.6
+  NewCops: enable
+  Exclude:
+    - 'examples/**/*'
+    - 'gemfiles/**/*'
+    - 'tmp/**/*'
+    - 'vendor/**/*'
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*'
+
+Layout/LineLength:
+  Exclude:
+    - 'spec/**/*'
+
+Naming/FileName:
+  Enabled: false
+
+Style/ClassVars:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in graphql-hive.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,58 @@
+PATH
+  remote: .
+  specs:
+    graphql-hive (0.1.0)
+      graphql (~> 2.0.9)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    diff-lcs (1.5.0)
+    graphql (2.0.9)
+    parallel (1.22.1)
+    parser (3.1.2.0)
+      ast (~> 2.4.1)
+    rainbow (3.1.1)
+    rake (10.5.0)
+    regexp_parser (2.5.0)
+    rexml (3.2.5)
+    rspec (3.11.0)
+      rspec-core (~> 3.11.0)
+      rspec-expectations (~> 3.11.0)
+      rspec-mocks (~> 3.11.0)
+    rspec-core (3.11.0)
+      rspec-support (~> 3.11.0)
+    rspec-expectations (3.11.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-mocks (3.11.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-support (3.11.0)
+    rubocop (1.30.1)
+      parallel (~> 1.10)
+      parser (>= 3.1.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.18.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.18.0)
+      parser (>= 3.1.1.0)
+    ruby-progressbar (1.11.0)
+    unicode-display_width (2.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.17)
+  graphql-hive!
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  rubocop (~> 1.30)
+
+BUNDLED WITH
+   1.17.3

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Charly POLY
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Charly POLY
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,144 @@
+# GraphQL Hive: `graphql-ruby` integration
+
+<p align="center">
+  <img src="cover.png" width="500" alt="GraphQL Hive" />
+</p>
+
+
+
+[GraphQL Hive](https://graphql-hive.com/) provides all the tools to get visibility of your GraphQL architecture at all stages, from standalone APIs to composed schemas (Federation, Stitching):
+- **Schema Registry** with custom breaking changes detection
+- **Monitoring** of RPM, latency, error rate and more
+- **Integrations** with your favorite tools (Slack, Github Actions and more)
+
+
+<br/>
+
+----
+
+<br/>
+
+
+# Getting started
+
+
+## 0. Get your Hive token
+
+If you are using Hive as a service, please refer to our documentation: https://docs.graphql-hive.com/features/tokens.
+
+## 1. Install the `graphql-hive` gem
+
+```
+gem install graphql-hive
+```
+
+<br/>
+
+## 2. Configure `GraphQL::Hive` in your Schema
+
+Add `GraphQL::Hive` **at the end** of your schema definition:
+
+```ruby
+class Schema < GraphQL::Schema
+  query QueryType
+
+  use(
+      GraphQL::Hive,
+      {
+        token: '<YOUR_TOKEN>',
+        reporting: {
+          author: ENV['GITHUB_USER'],
+          commit: ENV['GITHUB_COMMIT']
+        },
+      }
+  )
+end
+
+```
+
+The `reporting` configuration is required to push your GraphQL Schema to the Hive registry.
+Doing so will help better detect breaking changes and more upcoming features.
+If you only want to use the operations monitoring, replace the `monitoring` option with the following `report_schema: false`.
+
+<br/>
+
+
+**You are all set! 🚀**
+
+When deploying or starting up your GraphQL API, `graphql-hive` will immediately:
+- publish the schema to the Hive registry
+- forward the operations metrics to Hive
+
+
+<br/>
+
+## 3. See how your GraphQL API is operating
+
+You should now see operations information (RPM, error rate, queries performed) on your [GraphQL Hive dashboard](https://app.graphql-hive.com/):
+
+<p align="center">
+  <img src="operations-dashboard.png" width="500" alt="GraphQL Hive" />
+</p>
+
+
+<br/>
+
+
+## 4. Going further: use the Hive Github app
+
+Stay on top of your GraphQL Schema changes by installing the Hive Github Application and enabling Slack notifications about breaking changes:
+
+https://docs.graphql-hive.com/features/integrations#github
+
+<br/>
+
+----
+
+<br/>
+
+
+# Configuration
+
+You will find below the complete list of options of `GraphQL::Hive`:
+
+```ruby
+class MySchema < GraphQL::Schema
+  use(
+    GraphQL::Hive,
+    {
+      token: 'YOUR-TOKEN',
+      collect_usage: true, # optional
+      report_schema: true,  # optional
+      enabled: true, # Enable/Disable Hive Client (optional)
+      debug: false, # verbose logs
+      logger: MyLogger.new,  # optional
+      endpoint: 'app.graphql-hive.com',  # optional
+      port: 80,  # optional
+      buffer_size: 50, # forward the operations data to Hive every 50 requests
+      reporting: {  # mandatory if `report_schema: true`
+        # mandatory member of `reporting`
+        author: 'Author of the latest change',
+        # mandatory member of `reporting`
+        commit: 'git sha or any identifier',
+        service_name: '', # optional
+        service_url: '', # optional
+      },
+      # you can pass an optional proc that will help identify the client (ex: Apollo web app) that performed the query
+      client_info: Proc.new { |context| { name: context.client_name, version: context.client_version } }
+    }
+  )
+
+  # ...
+
+end
+```
+
+<br/>
+
+**A note on `buffer_size` and performances**
+
+The `graphql-hive` usage reporter, responsible for sending the operations data to Hive, is running in a separate `Thread` to avoid any major impact on your GraphQL API performances.
+
+If your GraphQL API has a high RPM, we encourage you to increase the `buffer_size` value.
+
+However, please note that a higher `buffer_size` value will introduce some peak of increase of memory comsumption.

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new
+
+task(default: %i[spec rubocop])

data/examples/simple-api/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gem 'graphql'
+gem 'graphql-hive', path: '../../'
+gem 'puma'
+gem 'rack-contrib'
+gem 'sinatra'
+gem 'sinatra-contrib'

data/examples/simple-api/Gemfile.lock

@@ -0,0 +1,48 @@
+PATH
+  remote: ../..
+  specs:
+    graphql-hive (0.1.0)
+      graphql (~> 2.0.9)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    graphql (2.0.9)
+    multi_json (1.15.0)
+    mustermann (1.1.1)
+      ruby2_keywords (~> 0.0.1)
+    nio4r (2.5.8)
+    puma (5.6.4)
+      nio4r (~> 2.0)
+    rack (2.2.3.1)
+    rack-contrib (2.3.0)
+      rack (~> 2.0)
+    rack-protection (2.2.0)
+      rack
+    ruby2_keywords (0.0.5)
+    sinatra (2.2.0)
+      mustermann (~> 1.0)
+      rack (~> 2.2)
+      rack-protection (= 2.2.0)
+      tilt (~> 2.0)
+    sinatra-contrib (2.2.0)
+      multi_json
+      mustermann (~> 1.0)
+      rack-protection (= 2.2.0)
+      sinatra (= 2.2.0)
+      tilt (~> 2.0)
+    tilt (2.0.10)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  graphql
+  graphql-hive!
+  puma
+  rack-contrib
+  sinatra
+  sinatra-contrib
+
+BUNDLED WITH
+   1.17.3

data/examples/simple-api/app.rb

@@ -0,0 +1,31 @@
+require 'sinatra'
+require 'sinatra/json'
+require 'rack/contrib'
+
+require_relative 'schema'
+
+# Test query:
+#
+# query GetPost($input: [PostInput!]!) {
+#   post(input: $input, test: TEST1) {
+#     title
+#     myId: id
+#   }
+# }
+
+class DemoApp < Sinatra::Base
+  use Rack::JSONBodyParser
+
+  post '/graphql' do
+    result = Schema.execute(
+      params['query'],
+      variables: params[:variables],
+      operation_name: params[:operationName],
+      context: {
+        client_name: 'GraphQL Client',
+        client_version: '1.0'
+      }
+    )
+    json result
+  end
+end

data/examples/simple-api/config.ru

@@ -0,0 +1,2 @@
+require './app'
+run DemoApp

data/examples/simple-api/schema.rb

@@ -0,0 +1,47 @@
+require 'graphql'
+require 'graphql-hive'
+
+module Types
+  class PostType < GraphQL::Schema::Object
+    description 'A blog post'
+    field :id, ID, null: false
+    field :title, String, null: false
+    # fields should be queried in camel-case (this will be `truncatedPreview`)
+    field :truncated_preview, String, null: false
+  end
+end
+
+class Types::PostInput < GraphQL::Schema::InputObject
+  description 'Query Post arguments'
+  argument :id, ID, required: true
+end
+
+class Types::TestEnum < GraphQL::Schema::Enum
+  value 'TEST1'
+  value 'TEST2'
+  value 'TEST3'
+end
+
+class QueryType < GraphQL::Schema::Object
+  description 'The query root of this schema'
+
+  # First describe the field signature:
+  field :post, Types::PostType, 'Find a post by ID' do
+    argument :input, [Types::PostInput]
+    argument :test, Types::TestEnum
+  end
+
+  # Then provide an implementation:
+  def post(input:, test:)
+    { id: 1, title: 'GraphQL Hive with `graphql-ruby`',
+      truncated_preview: 'Monitor operations, inspect your queries and publish your GraphQL schema with GraphQL Hive' }
+  end
+end
+
+class Schema < GraphQL::Schema
+  query QueryType
+
+  use(GraphQL::Hive, { buffer_size: 2, token: 'c3715c1afab97070c5c5b9bce8d02c7b', debug: true, reporting: { author: 'Charly Poly', commit: '109bb1e748bae21bdfe663c0ffc7e830' }, client_info: proc { |context|
+                                                                                                                                                                                                { name: context[:client_name], version: context[:client_version] }
+                                                                                                                                                                                              } })
+end

data/graphql-hive.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'graphql-hive/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'graphql-hive'
+  spec.version       = Graphql::Hive::VERSION
+  spec.authors       = ['Charly POLY']
+  spec.email         = ['cpoly55@gmail.com']
+
+  spec.summary       = '"GraphQL Hive integration for `graphql-ruby`"'
+  spec.description   = '"Monitor operations, inspect your queries and publish your GraphQL schema with GraphQL Hive"'
+  spec.homepage      = 'https://docs.graphql-hive.com/specs/integrations'
+  spec.license       = 'MIT'
+
+  spec.metadata      = { 'rubygems_mfa_required' => 'true' }
+
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.6.0')
+
+  spec.require_paths = ['lib']
+  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+
+  spec.add_dependency 'graphql', '~> 2.0.9'
+
+  spec.add_development_dependency 'bundler', '~> 1.17'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '~> 1.30'
+end

data/lib/graphql-hive/analyzer.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Hive < GraphQL::Tracing::PlatformTracing
+    # Fetch all users fields, input objects and enums
+    class Analyzer < GraphQL::Analysis::AST::Analyzer
+      def initialize(query_or_multiplex)
+        puts query_or_multiplex.inspect
+        super
+        @used_fields = Set.new
+      end
+
+      def on_leave_field(node, _parent, visitor)
+        @used_fields.add(visitor.parent_type_definition.graphql_name)
+        @used_fields.add([visitor.parent_type_definition.graphql_name, node.name].join('.'))
+      end
+
+      def on_leave_argument(node, parent, visitor)
+        @used_fields.add([visitor.parent_type_definition.graphql_name, parent.name, node.name].join('.'))
+
+        arg_type = visitor.argument_definition.type.unwrap
+        arg_type_kind = visitor.argument_definition.type.unwrap.kind
+        if arg_type_kind.input_object?
+          @used_fields.add(arg_type.graphql_name)
+          arg_type.arguments.each do |arg|
+            @used_fields.add([arg_type.graphql_name, arg[0]].join('.'))
+          end
+        elsif arg_type_kind.enum?
+          @used_fields.add([arg_type.graphql_name, node.value.name].join('.'))
+        end
+      end
+
+      attr_reader :used_fields
+
+      def result
+        @used_fields
+      end
+    end
+  end
+end

data/lib/graphql-hive/client.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+
+module GraphQL
+  class Hive < GraphQL::Tracing::PlatformTracing
+    # API client
+    class Client
+      def initialize(options)
+        @options = options
+      end
+
+      def send(path, body, _log_type)
+        uri =
+          URI::HTTP.build(
+            scheme: @options[:port].to_s == '443' ? 'https' : 'http',
+            host: @options[:endpoint] || 'app.graphql-hive.com',
+            port: @options[:port] || '443',
+            path: path
+          )
+
+        http = ::Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.read_timeout = 2
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request['content-type'] = 'application/json'
+        request['x-api-token'] = @options[:token]
+        request['User-Agent'] = "Hive@#{Graphql::Hive::VERSION}"
+        request['graphql-client-name'] = 'Hive Ruby Client'
+        request['graphql-client-version'] = Graphql::Hive::VERSION
+        request.body = JSON.generate(body)
+        response = http.request(request)
+
+        @options[:logger].debug(response.inspect)
+        @options[:logger].debug(response.body.inspect)
+      rescue StandardError => e
+        @options[:logger].fatal("Failed to send data: #{e}")
+      end
+    end
+  end
+end

data/lib/graphql-hive/printer.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Hive < GraphQL::Tracing::PlatformTracing
+    # - removes literals
+    # - removes aliases
+    # - sort nodes and directives (files, arguments, variables)
+    class Printer < GraphQL::Language::Printer
+      def print_node(node, indent: '')
+        case node
+        when Float, Integer
+          '0'
+        when String
+          ''
+        else
+          super(node, indent: indent)
+        end
+      end
+
+      # rubocop:disable Style/RedundantInterpolation
+      def print_field(field, indent: '')
+        out = "#{indent}".dup
+        out << "#{field.name}"
+        out << "(#{field.arguments.sort_by(&:name).map { |a| print_argument(a) }.join(', ')})" if field.arguments.any?
+        out << print_directives(field.directives)
+        out << print_selections(field.selections, indent: indent)
+        out
+      end
+      # rubocop:enable Style/RedundantInterpolation
+
+      def print_directives(directives)
+        super(directives.sort_by(&:name))
+      end
+
+      def print_selections(selections, indent: '')
+        super(selections.sort_by(&:name), indent: indent)
+      end
+
+      def print_directive(directive)
+        out = "@#{directive.name}".dup
+
+        if directive.arguments.any?
+          out << "(#{directive.arguments.sort_by(&:name).map { |a| print_argument(a) }.join(', ')})"
+        end
+
+        out
+      end
+
+      def print_operation_definition(operation_definition, indent: '')
+        out = "#{indent}#{operation_definition.operation_type}".dup
+        out << " #{operation_definition.name}" if operation_definition.name
+
+        # rubocop:disable Layout/LineLength
+        if operation_definition.variables.any?
+          out << "(#{operation_definition.variables.sort_by(&:name).map { |v| print_variable_definition(v) }.join(', ')})"
+        end
+        # rubocop:enable Layout/LineLength
+
+        out << print_directives(operation_definition.directives)
+        out << print_selections(operation_definition.selections, indent: indent)
+        out
+      end
+    end
+  end
+end

data/lib/graphql-hive/usage_reporter.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'graphql-hive/analyzer'
+require 'graphql-hive/printer'
+
+module GraphQL
+  class Hive < GraphQL::Tracing::PlatformTracing
+    # Report usage to Hive API without impacting application performances
+    class UsageReporter
+      @@instance = nil
+
+      @queue = nil
+      @thread = nil
+      @operations_buffer = nil
+      @client = nil
+      @logger = nil
+
+      def self.instance
+        @@instance
+      end
+
+      def initialize(options, client)
+        @@instance = self
+
+        @buffer_size = options[:buffer_size]
+        @logger = options[:logger]
+        @client = client
+        @operations_buffer = []
+
+        @queue = Queue.new
+
+        @thread = Thread.new do
+          while !@queue.empty? || !@queue.closed?
+            operations = @queue.pop(false)
+            process_operations operations
+          end
+        end
+      end
+
+      def add_operation(operation)
+        @logger.debug("add operation to buffer: #{operation}")
+
+        @operations_buffer << operation
+
+        return unless @operations_buffer.size >= @buffer_size
+
+        @logger.debug('buffer is full, sending!')
+        @queue.push @operations_buffer
+        @operations_buffer = []
+      end
+
+      def on_exit
+        @queue.push @operations_buffer unless @operations_buffer.empty?
+        @queue.close
+        @thread.join
+      end
+
+      private
+
+      def process_operations(operations)
+        report = {
+          size: 0,
+          map: {},
+          operations: []
+        }
+
+        operations.each do |operation|
+          add_operation_to_report(report, operation)
+        end
+
+        @logger.debug("sending report: #{report}")
+
+        @client.send('/usage', report, :usage)
+      end
+
+      def add_operation_to_report(report, operation)
+        timestamp, queries, results, duration = operation
+
+        errors = errors_from_results(results)
+
+        operation_name = queries.map(&:operations).map(&:keys).flatten.compact.join(', ')
+        operation = ''
+        fields = Set.new
+
+        queries.each do |query|
+          analyzer = GraphQL::Hive::Analyzer.new(query)
+          visitor = GraphQL::Analysis::AST::Visitor.new(
+            query: query,
+            analyzers: [analyzer]
+          )
+
+          visitor.visit
+
+          fields.merge(analyzer.result)
+
+          operation += "\n" unless operation.empty?
+          operation += GraphQL::Hive::Printer.new.print(visitor.result)
+        end
+
+        md5 = Digest::MD5.new
+        md5.update operation
+        operation_map_key = md5.hexdigest
+
+        operation_record = {
+          operationMapKey: operation_map_key,
+          timestamp: timestamp.to_i,
+          execution: {
+            ok: errors[:errorsTotal].zero?,
+            duration: duration,
+            errorsTotal: errors[:errorsTotal],
+            errors: errors[:errors]
+          }
+        }
+
+        # context = results[0].query.context
+        # TBD
+        # operation_record[:metadata] = { client: @options[:client_info].call(context) } if @options[:client_info]
+
+        report[:map][operation_map_key] = {
+          fields: fields.to_a,
+          operationName: operation_name,
+          operation: operation
+        }
+        report[:operations] << operation_record
+        report[:size] += 1
+      end
+
+      def errors_from_results(results)
+        acc = { errorsTotal: 0, errors: [] }
+        results.each do |result|
+          errors = result.to_h.fetch('errors', [])
+          errors.each do |error|
+            acc[:errorsTotal] += 1
+            acc[:errors] << { message: error['message'], path: error['path'].join('.') }
+          end
+        end
+        acc
+      end
+    end
+  end
+end

data/lib/graphql-hive/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Graphql
+  module Hive
+    VERSION = '0.1.0'
+  end
+end

data/lib/graphql-hive.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+require 'graphql-hive/version'
+require 'graphql-hive/usage_reporter'
+require 'graphql-hive/client'
+
+# class MySchema < GraphQL::Schema
+#   use(
+#     GraphQL::Hive,
+#     {
+#       token: 'YOUR-TOKEN',
+#       collect_usage: true,
+#       report_schema: true,
+#       enabled: true, // Enable/Disable Hive Client
+#       debug: true, // Debugging mode
+#       logger: MyLogger.new,
+#       endpoint: 'app.graphql-hive.com',
+#       port: 80,
+#       reporting: {
+#         author: 'Author of the latest change',
+#         commit: 'git sha or any identifier',
+#         service_name: '',
+#         service_url: '',
+#       },
+#       client_info: Proc.new { |context| { name: context.client_name, version: context.client_version } }
+#     }
+#   )
+#
+#   # ...
+#
+# end
+
+module GraphQL
+  # GraphQL Hive usage collector and schema reporter
+  class Hive < GraphQL::Tracing::PlatformTracing
+    @@schema = nil
+    @@instance = nil
+
+    @usage_reporter = nil
+    @client = nil
+
+    REPORT_SCHEMA_MUTATION = <<~MUTATION
+      mutation schemaPublish($input: SchemaPublishInput!) {
+        schemaPublish(input: $input) {
+          __typename
+        }
+      }
+    MUTATION
+
+    DEFAULT_OPTIONS = {
+      enabled: true,
+      collect_usage: true,
+      read_operations: true,
+      report_schema: true,
+      buffer_size: 50,
+      logger: nil
+    }.freeze
+
+    self.platform_keys = {
+      'lex' => 'lex',
+      'parse' => 'parse',
+      'validate' => 'validate',
+      'analyze_query' => 'analyze_query',
+      'analyze_multiplex' => 'analyze_multiplex',
+      'execute_multiplex' => 'execute_multiplex',
+      'execute_query' => 'execute_query',
+      'execute_query_lazy' => 'execute_query_lazy'
+    }
+
+    def initialize(options = {})
+      opts = DEFAULT_OPTIONS.merge(options)
+      validate_options!(opts)
+      super(opts)
+
+      @@instance = self
+
+      @client = GraphQL::Hive::Client.new(opts)
+      @usage_reporter = GraphQL::Hive::UsageReporter.new(opts, @client)
+
+      # buffer
+      @report = {
+        size: 0,
+        map: {},
+        operations: []
+      }
+
+      send_report_schema(@@schema) if @@schema && opts[:report_schema] && @options[:enabled]
+    end
+
+    def self.instance
+      @@instance
+    end
+
+    def self.use(schema, **kwargs)
+      @@schema = schema
+      super
+    end
+
+    # called on trace events
+    def platform_trace(platform_key, _key, data)
+      return yield unless @options[:enabled] && @options[:collect_usage]
+
+      if platform_key == 'execute_multiplex'
+        if data[:multiplex]
+          queries = data[:multiplex].queries
+          timestamp = (Time.now.utc.to_f * 1000).to_i
+          starting = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          results = yield
+          ending = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          elapsed = ending - starting
+          duration = (elapsed.to_f * (10**9)).to_i
+
+          report_usage(timestamp, queries, results, duration) unless queries.empty?
+
+          results
+        else
+          yield
+        end
+      else
+        yield
+      end
+    end
+
+    # compat
+    def platform_authorized_key(type)
+      "#{type.graphql_name}.authorized.graphql"
+    end
+
+    # compat
+    def platform_resolve_type_key(type)
+      "#{type.graphql_name}.resolve_type.graphql"
+    end
+
+    # compat
+    def platform_field_key(type, field)
+      "graphql.#{type.name}.#{field.name}"
+    end
+
+    def on_exit
+      @usage_reporter.on_exit
+    end
+
+    private
+
+    def validate_options!(options)
+      if options[:logger].nil?
+        options[:logger] = Logger.new($stdout)
+        original_formatter = Logger::Formatter.new
+        options[:logger].formatter = proc { |severity, datetime, progname, msg|
+          original_formatter.call(severity, datetime, progname, "[hive] #{msg.dump}")
+        }
+      end
+      if !options.include?(:token) && (!options.include?(:enabled) || options.enabled)
+        options[:logger].warn('`token` options is missing')
+        options[:enabled] = false
+        false
+      elsif options[:report_schema] &&
+            (
+              !options.include?(:reporting) ||
+              (
+                options.include?(:reporting) && (
+                  !options[:reporting].include?(:author) || !options[:reporting].include?(:commit)
+                )
+              )
+            )
+
+        options[:logger].warn('`reporting.author` and `reporting.commit` options are required')
+        false
+      end
+      true
+    end
+
+    def report_usage(timestamp, queries, results, duration)
+      @usage_reporter.add_operation([timestamp, queries, results, duration])
+    end
+
+    def send_report_schema(schema)
+      sdl = GraphQL::Schema::Printer.new(schema).print_schema
+
+      body = {
+        query: REPORT_SCHEMA_MUTATION,
+        operationName: 'schemaPublish',
+        variables: {
+          input: {
+            sdl: sdl,
+            author: @options[:reporting][:author],
+            commit: @options[:reporting][:commit],
+            service: @options[:reporting][:service_name],
+            url: @options[:reporting][:service_url],
+            force: true
+          }
+        }
+      }
+
+      puts(JSON.generate(body))
+
+      @client.send('/registry', body, :'report-schema')
+    end
+  end
+end
+
+at_exit do
+  GraphQL::Hive.instance&.on_exit
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: graphql-hive
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Charly POLY
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-06-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.9
+- !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: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.30'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.30'
+description: '"Monitor operations, inspect your queries and publish your GraphQL schema
+  with GraphQL Hive"'
+email:
+- cpoly55@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- cover.png
+- examples/simple-api/Gemfile
+- examples/simple-api/Gemfile.lock
+- examples/simple-api/app.rb
+- examples/simple-api/config.ru
+- examples/simple-api/schema.rb
+- graphql-hive.gemspec
+- lib/graphql-hive.rb
+- lib/graphql-hive/analyzer.rb
+- lib/graphql-hive/client.rb
+- lib/graphql-hive/printer.rb
+- lib/graphql-hive/usage_reporter.rb
+- lib/graphql-hive/version.rb
+- operations-dashboard.png
+homepage: https://docs.graphql-hive.com/specs/integrations
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key:
+specification_version: 4
+summary: '"GraphQL Hive integration for `graphql-ruby`"'
+test_files: []