apollo-studio-tracing 1.0.0.beta.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5e5e5b59a3310a3863053df2f9a0534ad3b0ce2faa60b6ce69803be0be1c9a24
+  data.tar.gz: 604ad5829a5fc0034d2afed4ce72aff5679648fd8a3976683efc9a2bd36b3e7e
+SHA512:
+  metadata.gz: d4439961889fdd4f5bbd6810b9293e2fd4eeb0e9056faa096e406ef32994efde30ae0b85d1b7930336d5b25c0195b24f386e40c228c53d569f05c0db3cff74fc
+  data.tar.gz: 82036596d4287c2a10b82b00ef79e602430efb0b9d95682ba87d1a109d62498fc662a3a0d5d5ddd6522307276858ebb4e11d9e9f3d48ff5de6c98d0cae8008db

data/CHANGELOG.md

@@ -0,0 +1,27 @@
+# [1.0.0-beta.1](https://github.com/EnjoyTech/apollo-studio-tracing-ruby/compare/v0.1.0...v1.0.0-beta.1) (2020-10-23)
+
+
+### Bug Fixes
+
+* revert Rails.logger reference, doesn't work correctly in non-Rails environment ([eeea691](https://github.com/EnjoyTech/apollo-studio-tracing-ruby/commit/eeea6913be0171db0b45c58ff6b34dddbbea764b))
+* **debug:** add debug queueing ([074bb79](https://github.com/EnjoyTech/apollo-studio-tracing-ruby/commit/074bb79aef78a7b5f65744dd5a6ea4a913de4338))
+* **tracing:** ensure thread started when queueing traces ([4bb2238](https://github.com/EnjoyTech/apollo-studio-tracing-ruby/commit/4bb22387fc5230909b1201a58b7be922a153dcb7))
+* properly capture errors and record them on traces ([3ba25ff](https://github.com/EnjoyTech/apollo-studio-tracing-ruby/commit/3ba25fff60efab9a98f6212192b7543de9a19057))
+* use Rails.logger if it exists ([b0a7103](https://github.com/EnjoyTech/apollo-studio-tracing-ruby/commit/b0a7103882cda74dbcf39cf6f84339e655e3506b))
+* **tracing:** fix multiplexed tracing ([43b6c86](https://github.com/EnjoyTech/apollo-studio-tracing-ruby/commit/43b6c86006be2f300211b2c2bccdf5b8d0ffc658))
+* remove NotInstalledError, remove unused src file ([dc8e31d](https://github.com/EnjoyTech/apollo-studio-tracing-ruby/commit/dc8e31da901c998ef1bafc6a5b28aae51f3ee0c6))
+
+
+### chore
+
+* remove debug statements, initial release! ([5f634c0](https://github.com/EnjoyTech/apollo-studio-tracing-ruby/commit/5f634c05f5560fa6cf9f68cfb5837c715828214c))
+
+
+### BREAKING CHANGES
+
+* Initial release. Substantially divergent from `apollo-federation-ruby`, so marking
+this as a breaking change.
+
+## 1.0.0 (2020-10-23)
+
+- First release, based on https://github.com/Gusto/apollo-federation-ruby

data/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2017 Reginald
+Copyright (c) 2019 Gusto
+Copyright (c) 2020 Enjoy Technology Inc.
+
+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,71 @@
+# apollo-studio-tracing
+
+[![CircleCI](https://circleci.com/gh/EnjoyTech/apollo-studio-tracing-ruby/tree/master.svg?style=svg)](https://circleci.com/gh/EnjoyTech/apollo-studio-tracing-ruby/tree/master)
+
+This gem extends the [GraphQL Ruby](http://graphql-ruby.org/) gem to add support for sending trace data to [Apollo Studio](https://www.apollographql.com/docs/studio/). It is intended to be a full-featured replacement for the unmaintained [apollo-tracing-ruby](https://github.com/uniiverse/apollo-tracing-ruby) gem, and it is built HEAVILY from the work done within the Gusto [apollo-federation-ruby](https://github.com/Gusto/apollo-federation-ruby) gem.
+
+## DISCLAIMER
+
+This gem is still in a beta stage and may have some bugs or incompatibilities. See the [Known Issues and Limitations](#known-issues-and-limitations) below. If you run into any problems, please [file an issue](https://github.com/EnjoyTech/apollo-studio-tracing-ruby/issues).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'apollo-studio-tracing'
+```
+
+And then execute:
+
+```
+$ bundle install
+```
+
+Or install it yourself as:
+
+```
+$ gem install apollo-studio-tracing
+```
+
+## Getting Started
+
+1. Add `use ApolloStudioTracing` to your schema class.
+2. Change your controller to add `apollo_tracing_enabled: true` to the execution context. Ensure that `apollo_client_name` and `apollo_client_version` are set as well, for proper client information in Studio:
+
+   ```ruby
+   def execute
+     # ...
+     context = {
+       apollo_client_name: request.headers["apollographql-client-name"],
+       apollo_client_version: request.headers["apollographql-client-version"],
+       apollo_tracing_enabled: Rails.env.production?,
+     }
+     # ...
+   end
+   ```
+
+### Updating the Apollo .proto definition
+
+Install [Google Protocol Buffers](https://github.com/protocolbuffers/protobuf) via Homebrew
+
+```
+$ brew install protobuf
+```
+
+Regenerate the Ruby protos with the included script:
+
+```
+$ bin/generate-proto.sh
+Removing old client
+Downloading latest Apollo Protobuf IDL
+Generating Ruby client stubs
+```
+
+## Known Issues and Limitations
+
+- Only works with class-based schemas, the legacy `.define` API will not be supported
+
+## Maintainers
+
+- [Luke Sanwick](https://github.com/lsanwick)

data/bin/generate-protos.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+
+set -eo pipefail
+
+DIR=`dirname "$0"`
+OUTPUT_DIR=$DIR/../lib/apollo-studio-tracing/proto
+
+echo "Removing old client"
+rm -f $OUTPUT_DIR/apollo.proto $OUTPUT_DIR/apollo_pb.rb
+
+echo "Downloading latest Apollo Protobuf IDL"
+curl --silent --output $OUTPUT_DIR/apollo.proto https://raw.githubusercontent.com/apollographql/apollo-server/main/packages/apollo-reporting-protobuf/src/reports.proto
+
+echo "Generating Ruby client stubs"
+protoc -I $OUTPUT_DIR --ruby_out $OUTPUT_DIR $OUTPUT_DIR/apollo.proto

data/bin/rspec

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile',
+                                           Pathname.new(__FILE__).realpath,)
+
+bundle_binstub = File.expand_path('bundle', __dir__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('rspec-core', 'rspec')

data/lib/apollo-studio-tracing.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'apollo-studio-tracing/proto'
+require 'apollo-studio-tracing/node_map'
+require 'apollo-studio-tracing/tracer'
+
+module ApolloStudioTracing
+  extend self
+
+  KEY = :apollo_trace
+  DEBUG_KEY = "#{KEY}_debug".to_sym
+
+  attr_accessor :logger
+
+  # TODO: Initialize this to Rails.logger in a Railtie
+  self.logger = Logger.new(STDOUT)
+
+  def use(schema, **options)
+    tracer = ApolloStudioTracing::Tracer.new(**options)
+    # TODO: Shutdown tracers when reloading code in Rails
+    # (although it's unlikely you'll have Apollo Tracing enabled in development)
+    tracers << tracer
+    schema.tracer(tracer)
+    tracer.start_trace_channel
+  end
+
+  def flush
+    tracers.each(&:flush_trace_channel)
+  end
+
+  def shutdown
+    tracers.each(&:shutdown_trace_channel)
+  end
+
+  trap('SIGINT') do
+    Thread.new { shutdown }
+  end
+
+  private
+
+  def tracers
+    @tracers ||= []
+  end
+end

data/lib/apollo-studio-tracing/api.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'openssl'
+require 'uri'
+require 'zlib'
+
+module ApolloStudioTracing
+  module API
+    extend self
+
+    APOLLO_URL = 'https://engine-report.apollodata.com/api/ingress/traces'
+    APOLLO_URI = ::URI.parse(APOLLO_URL)
+    UploadAttemptError = Class.new(StandardError)
+    RetryableUploadAttemptError = Class.new(UploadAttemptError)
+
+    def upload(report_data, max_attempts:, min_retry_delay_secs:, **options)
+      attempt ||= 0
+      attempt_upload(report_data, **options)
+    rescue UploadAttemptError => e
+      attempt += 1
+      if e.is_a?(RetryableUploadAttemptError) && attempt < max_attempts
+        retry_delay = min_retry_delay_secs * 2**attempt
+        ApolloStudioTracing.logger.warn(
+          "Attempt to send Apollo trace report failed and will be retried in #{retry_delay} " \
+          "secs: #{e.message}",
+        )
+        sleep(retry_delay)
+        retry
+      else
+        ApolloStudioTracing.logger.warn("Failed to send Apollo trace report: #{e.message}")
+      end
+    end
+
+    private
+
+    def attempt_upload(report_data, compress:, api_key:)
+      body = compress ? gzip(report_data) : report_data
+      headers = { 'X-Api-Key' => api_key }
+      headers['Content-Encoding'] = 'gzip' if compress
+      result = Net::HTTP.post(APOLLO_URI, body, headers)
+
+      if result.is_a?(Net::HTTPServerError)
+        raise RetryableUploadAttemptError, "#{result.code} #{result.message} - #{result.body}"
+      end
+
+      if !result.is_a?(Net::HTTPSuccess)
+        raise UploadAttemptError, "#{result.message} (#{result.code}) - #{result.body}"
+      end
+    rescue IOError, SocketError, SystemCallError, OpenSSL::OpenSSLError => e
+      raise RetryableUploadAttemptError, "#{e.class} - #{e.message}"
+    end
+
+    def gzip(data)
+      output = StringIO.new
+      output.set_encoding('BINARY')
+      gz = Zlib::GzipWriter.new(output)
+      gz.write(data)
+      gz.close
+      output.string
+    end
+  end
+end

data/lib/apollo-studio-tracing/node_map.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'apollo-studio-tracing/proto'
+
+module ApolloStudioTracing
+  # NodeMap stores a flat map of trace nodes by stringified paths
+  # (i.e. "_entities.0.id") for fast lookup when we need to alter
+  # nodes (to add end times or errors.)
+  #
+  # When adding a node to the NodeMap, it will create any missing
+  # parent nodes and ensure the tree is consistent.
+  #
+  # Only the "root" node is attached to the trace extension.
+  class NodeMap
+    ROOT_KEY = ''
+
+    attr_reader :nodes
+    def initialize
+      @nodes = {
+        ROOT_KEY => ApolloStudioTracing::Node.new,
+      }
+    end
+
+    def root
+      nodes[ROOT_KEY]
+    end
+
+    def node_for_path(path)
+      nodes[array_wrap(path).join('.')]
+    end
+
+    def add(path)
+      node = ApolloStudioTracing::Node.new
+      node_key = path.join('.')
+      key = path.last
+
+      case key
+      when String # field
+        node.response_name = key
+      when Integer # index of an array
+        node.index = key
+      end
+
+      nodes[node_key] = node
+
+      # find or create a parent node and add this node to its children
+      parent_path = path[0..-2]
+      parent_node = nodes[parent_path.join('.')] || add(parent_path)
+      parent_node.child << node
+
+      node
+    end
+
+    def add_error(error)
+      path = array_wrap(error['path']).join('.')
+      node = nodes[path] || root
+
+      locations = array_wrap(error['locations']).map do |location|
+        ApolloStudioTracing::Location.new(location)
+      end
+
+      node.error << ApolloStudioTracing::Error.new(
+        message: error['message'],
+        location: locations,
+        json: JSON.dump(error),
+      )
+    end
+
+    def array_wrap(object)
+      if object.nil?
+        []
+      elsif object.respond_to?(:to_ary)
+        object.to_ary || [object]
+      else
+        [object]
+      end
+    end
+  end
+end

data/lib/apollo-studio-tracing/proto.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'proto/apollo_pb'
+
+module ApolloStudioTracing
+  Trace = ::Mdg::Engine::Proto::Trace
+  TracesAndStats = ::Mdg::Engine::Proto::TracesAndStats
+  Node = ::Mdg::Engine::Proto::Trace::Node
+  Location = ::Mdg::Engine::Proto::Trace::Location
+  Error = ::Mdg::Engine::Proto::Trace::Error
+  ReportHeader = ::Mdg::Engine::Proto::ReportHeader
+  Report = ::Mdg::Engine::Proto::Report
+end

data/lib/apollo-studio-tracing/proto/apollo.proto

@@ -0,0 +1,381 @@
+syntax = "proto3";
+
+package mdg.engine.proto;
+
+import "google/protobuf/timestamp.proto";
+
+message Trace {
+	message CachePolicy {
+		enum Scope {
+			UNKNOWN = 0;
+			PUBLIC = 1;
+			PRIVATE = 2;
+		}
+
+		Scope scope = 1;
+		int64 max_age_ns = 2; // use 0 for absent, -1 for 0
+	}
+
+	message Details {
+		// The variables associated with this query (unless the reporting agent is
+		// configured to keep them all private). Values are JSON: ie, strings are
+		// enclosed in double quotes, etc.  The value of a private variable is
+		// the empty string.
+		map<string, string> variables_json = 4;
+		// Deprecated. Engineproxy did not encode variable values as JSON, so you
+		// couldn't tell numbers from numeric strings. Send variables_json instead.
+		map<string, bytes> deprecated_variables = 1;
+		// This is deprecated and only used for legacy applications
+		// don't include this in traces inside a FullTracesReport; the operation
+		// name for these traces comes from the key of the traces_per_query map.
+		string operation_name = 3;
+	}
+
+	message Error {
+		string message = 1; // required
+		repeated Location location = 2;
+		uint64 time_ns = 3;
+		string json = 4;
+	}
+
+	message HTTP {
+		message Values {
+			repeated string value = 1;
+		}
+
+		enum Method {
+			UNKNOWN = 0;
+			OPTIONS = 1;
+			GET = 2;
+			HEAD = 3;
+			POST = 4;
+			PUT = 5;
+			DELETE = 6;
+			TRACE = 7;
+			CONNECT = 8;
+			PATCH = 9;
+		}
+		Method method = 1;
+		string host = 2;
+		string path = 3;
+
+		// Should exclude manual blacklist ("Auth" by default)
+		map<string, Values> request_headers = 4;
+		map<string, Values> response_headers = 5;
+
+		uint32 status_code = 6;
+
+		bool secure = 8; // TLS was used
+		string protocol = 9; // by convention "HTTP/1.0", "HTTP/1.1", "HTTP/2" or "h2"
+	}
+
+	message Location {
+		uint32 line = 1;
+		uint32 column = 2;
+	}
+
+	// We store information on each resolver execution as a Node on a tree.
+	// The structure of the tree corresponds to the structure of the GraphQL
+	// response; it does not indicate the order in which resolvers were
+	// invoked.  Note that nodes representing indexes (and the root node)
+	// don't contain all Node fields (eg types and times).
+	message Node {
+		// The name of the field (for Nodes representing a resolver call) or the
+		// index in a list (for intermediate Nodes representing elements of a list).
+		// field_name is the name of the field as it appears in the GraphQL
+		// response: ie, it may be an alias.  (In that case, the original_field_name
+		// field holds the actual field name from the schema.) In any context where
+		// we're building up a path, we use the response_name rather than the
+		// original_field_name.
+		oneof id {
+			string response_name = 1;
+			uint32 index = 2;
+		}
+
+		string original_field_name = 14;
+
+		// The field's return type; e.g. "String!" for User.email:String!
+		string type = 3;
+
+		// The field's parent type; e.g. "User" for User.email:String!
+		string parent_type = 13;
+
+		CachePolicy cache_policy = 5;
+
+		// relative to the trace's start_time, in ns
+		uint64 start_time = 8;
+		// relative to the trace's start_time, in ns
+		uint64 end_time = 9;
+
+		repeated Error error = 11;
+		repeated Node child = 12;
+
+		reserved 4;
+	}
+
+	// represents a node in the query plan, under which there is a trace tree for that service fetch.
+	// In particular, each fetch node represents a call to an implementing service, and calls to implementing
+	// services may not be unique. See https://github.com/apollographql/apollo-server/blob/main/packages/apollo-gateway/src/QueryPlan.ts
+	// for more information and details.
+	message QueryPlanNode {
+		// This represents a set of nodes to be executed sequentially by the Gateway executor
+		message SequenceNode {
+			repeated QueryPlanNode nodes = 1;
+		}
+		// This represents a set of nodes to be executed in parallel by the Gateway executor
+		message ParallelNode {
+			repeated QueryPlanNode nodes = 1;
+		}
+		// This represents a node to send an operation to an implementing service
+		message FetchNode {
+			// XXX When we want to include more details about the sub-operation that was
+			// executed against this service, we should include that here in each fetch node.
+			// This might include an operation signature, requires directive, reference resolutions, etc.
+			string service_name = 1;
+
+			bool trace_parsing_failed = 2;
+
+			// This Trace only contains start_time, end_time, duration_ns, and root;
+			// all timings were calculated **on the federated service**, and clock skew
+			// will be handled by the ingress server.
+			Trace trace = 3;
+
+			// relative to the outer trace's start_time, in ns, measured in the gateway.
+			uint64 sent_time_offset = 4;
+
+			// Wallclock times measured in the gateway for when this operation was
+			// sent and received.
+			google.protobuf.Timestamp sent_time = 5;
+			google.protobuf.Timestamp received_time = 6;
+		}
+
+		// This node represents a way to reach into the response path and attach related entities.
+		// XXX Flatten is really not the right name and this node may be renamed in the query planner.
+		message FlattenNode {
+			repeated ResponsePathElement response_path = 1;
+			QueryPlanNode node = 2;
+		}
+		message ResponsePathElement {
+			oneof id {
+				string field_name = 1;
+				uint32 index = 2;
+			}
+		}
+		oneof node {
+			SequenceNode sequence = 1;
+			ParallelNode parallel = 2;
+			FetchNode fetch = 3;
+			FlattenNode flatten = 4;
+		}
+	}
+
+	// Wallclock time when the trace began.
+	google.protobuf.Timestamp start_time = 4; // required
+	// Wallclock time when the trace ended.
+	google.protobuf.Timestamp end_time = 3; // required
+	// High precision duration of the trace; may not equal end_time-start_time
+	// (eg, if your machine's clock changed during the trace).
+	uint64 duration_ns = 11; // required
+	// A tree containing information about all resolvers run directly by this
+	// service, including errors.
+	Node root = 14;
+
+	// -------------------------------------------------------------------------
+	// Fields below this line are *not* included in federated traces (the traces
+	// sent from federated services to the gateway).
+
+	// In addition to details.raw_query, we include a "signature" of the query,
+	// which can be normalized: for example, you may want to discard aliases, drop
+	// unused operations and fragments, sort fields, etc. The most important thing
+	// here is that the signature match the signature in StatsReports. In
+	// StatsReports signatures show up as the key in the per_query map (with the
+	// operation name prepended).  The signature should be a valid GraphQL query.
+	// All traces must have a signature; if this Trace is in a FullTracesReport
+	// that signature is in the key of traces_per_query rather than in this field.
+	// Engineproxy provides the signature in legacy_signature_needs_resigning
+	// instead.
+	string signature = 19;
+
+	Details details = 6;
+
+	// Note: engineproxy always sets client_name, client_version, and client_address to "none".
+	// apollo-engine-reporting allows for them to be set by the user.
+	string client_name = 7;
+	string client_version = 8;
+	string client_address = 9;
+	string client_reference_id = 23;
+
+	HTTP http = 10;
+
+	CachePolicy cache_policy = 18;
+
+	// If this Trace was created by a gateway, this is the query plan, including
+	// sub-Traces for federated services. Note that the 'root' tree on the
+	// top-level Trace won't contain any resolvers (though it could contain errors
+	// that occurred in the gateway itself).
+	QueryPlanNode query_plan = 26;
+
+	// Was this response served from a full query response cache?  (In that case
+	// the node tree will have no resolvers.)
+	bool full_query_cache_hit = 20;
+
+	// Was this query specified successfully as a persisted query hash?
+	bool persisted_query_hit = 21;
+	// Did this query contain both a full query string and a persisted query hash?
+	// (This typically means that a previous request was rejected as an unknown
+	// persisted query.)
+	bool persisted_query_register = 22;
+
+	// Was this operation registered and a part of the safelist?
+	bool registered_operation = 24;
+
+	// Was this operation forbidden due to lack of safelisting?
+	bool forbidden_operation = 25;
+
+	// --------------------------------------------------------------
+	// Fields below this line are only set by the old Go engineproxy.
+
+	// Older agents (eg the Go engineproxy) relied to some degree on the Engine
+	// backend to run their own semi-compatible implementation of a specific
+	// variant of query signatures. The backend does not do this for new agents (which
+	// set the above 'signature' field). It used to still "re-sign" signatures
+	// from engineproxy, but we've now simplified the backend to no longer do this.
+	// Deprecated and ignored in FullTracesReports.
+	string legacy_signature_needs_resigning = 5;
+
+	// removed: Node parse = 12; Node validate = 13;
+	//          Id128 server_id = 1; Id128 client_id = 2;
+	reserved 12, 13, 1, 2;
+}
+
+// The `service` value embedded within the header key is not guaranteed to contain an actual service,
+// and, in most cases, the service information is trusted to come from upstream processing. If the
+// service _is_ specified in this header, then it is checked to match the context that is reporting it.
+// Otherwise, the service information is deduced from the token context of the reporter and then sent
+// along via other mechanisms (in Kafka, the `ReportKafkaKey). The other information (hostname,
+// agent_version, etc.) is sent by the Apollo Engine Reporting agent, but we do not currently save that
+// information to any of our persistent storage.
+message ReportHeader {
+	// eg "host-01.example.com"
+	string hostname = 5;
+
+	// eg "engineproxy 0.1.0"
+	string agent_version = 6; // required
+	// eg "prod-4279-20160804T065423Z-5-g3cf0aa8" (taken from `git describe --tags`)
+	string service_version = 7;
+	// eg "node v4.6.0"
+	string runtime_version = 8;
+	// eg "Linux box 4.6.5-1-ec2 #1 SMP Mon Aug 1 02:31:38 PDT 2016 x86_64 GNU/Linux"
+	string uname = 9;
+	// eg "current", "prod"
+	string schema_tag = 10;
+	// An id that is used to represent the schema to Apollo Graph Manager
+	// Using this in place of what used to be schema_hash, since that is no longer
+	// attached to a schema in the backend.
+	string executable_schema_id = 11;
+
+	reserved 3; // removed string service = 3;
+}
+
+message PathErrorStats {
+	map<string, PathErrorStats> children = 1;
+	uint64 errors_count = 4;
+	uint64 requests_with_errors_count = 5;
+}
+
+message QueryLatencyStats {
+	repeated int64 latency_count = 1;
+	uint64 request_count = 2;
+	uint64 cache_hits = 3;
+	uint64 persisted_query_hits = 4;
+	uint64 persisted_query_misses = 5;
+	repeated int64 cache_latency_count = 6;
+	PathErrorStats root_error_stats = 7;
+	uint64 requests_with_errors_count = 8;
+	repeated int64 public_cache_ttl_count = 9;
+	repeated int64 private_cache_ttl_count = 10;
+	uint64 registered_operation_count = 11;
+	uint64 forbidden_operation_count = 12;
+}
+
+message StatsContext {
+	string client_reference_id = 1;
+	string client_name = 2;
+	string client_version = 3;
+}
+
+message ContextualizedQueryLatencyStats {
+	QueryLatencyStats query_latency_stats = 1;
+	StatsContext context = 2;
+}
+
+message ContextualizedTypeStats {
+	StatsContext context = 1;
+	map<string, TypeStat> per_type_stat = 2;
+}
+
+message FieldStat {
+	string return_type = 3; // required; eg "String!" for User.email:String!
+	uint64 errors_count = 4;
+	uint64 count = 5;
+	uint64 requests_with_errors_count = 6;
+	repeated int64 latency_count = 8; // Duration histogram; see docs/histograms.md
+	reserved 1, 2, 7;
+}
+
+message TypeStat {
+	// Key is (eg) "email" for User.email:String!
+	map<string, FieldStat> per_field_stat = 3;
+	reserved 1, 2;
+}
+
+message Field {
+	string name = 2; // required; eg "email" for User.email:String!
+	string return_type = 3; // required; eg "String!" for User.email:String!
+}
+
+message Type {
+	string name = 1; // required; eg "User" for User.email:String!
+	repeated Field field = 2;
+}
+
+// This is the top-level message used by the new traces ingress. This
+// is designed for the apollo-engine-reporting TypeScript agent and will
+// eventually be documented as a public ingress API. This message consists
+// solely of traces; the equivalent of the StatsReport is automatically
+// generated server-side from this message. Agent should either send a trace or include it in the stats
+// for every request in this report. Generally, buffering up until a large
+// size has been reached (say, 4MB) or 5-10 seconds has passed is appropriate.
+// This message used to be know as FullTracesReport, but got renamed since it isn't just for traces anymore
+message Report {
+	ReportHeader header = 1;
+
+	// key is statsReportKey (# operationName\nsignature) Note that the nested
+	// traces will *not* have a signature or details.operationName (because the
+	// key is adequate).
+	//
+	// We also assume that traces don't have
+	// legacy_per_query_implicit_operation_name, and we don't require them to have
+	// details.raw_query (which would consume a lot of space and has privacy/data
+	// access issues, and isn't currently exposed by our app anyway).
+	map<string, TracesAndStats> traces_per_query = 5;
+
+	// This is the time that the requests in this trace are considered to have taken place
+	// If this field is not present the max of the end_time of each trace will be used instead.
+	// If there are no traces and no end_time present the report will not be able to be processed.
+	// Note: This will override the end_time from traces.
+	google.protobuf.Timestamp end_time = 2; // required if no traces in this message
+}
+
+message ContextualizedStats {
+	StatsContext context = 1;
+	QueryLatencyStats query_latency_stats = 2;
+	// Key is type name.
+	map<string, TypeStat> per_type_stat = 3;
+}
+
+// A sequence of traces and stats. An individual trace should either be counted as a stat or trace
+message TracesAndStats {
+	repeated Trace trace = 1;
+	repeated ContextualizedStats stats_with_context = 2;
+}