optics-agent 0.1.0

data/lib/optics-agent/instrumentation/query-schema.rb

@@ -0,0 +1,9 @@
+module OpticsAgent
+  module Instrumentation
+    INTROSPECTION_QUERY ||= IO.read("#{File.dirname(__FILE__)}/introspection-query.graphql")
+
+    def introspect_schema(schema)
+      schema.execute(INTROSPECTION_QUERY)['data']['__schema']
+    end
+  end
+end

data/lib/optics-agent/normalization/latency.rb

@@ -0,0 +1,14 @@
+module OpticsAgent
+  module Normalization
+    def empty_latency_count
+      Array.new(256) { 0 }
+    end
+
+    # see https://github.com/apollostack/optics-agent/blob/master/docs/histograms.md
+    def latency_bucket(micros)
+      bucket = Math.log(micros) / Math.log(1.1)
+
+      [255, [0, bucket].max].min.ceil.to_i
+    end
+  end
+end

data/lib/optics-agent/normalization/query.rb

@@ -0,0 +1,156 @@
+require 'graphql'
+
+module OpticsAgent
+  module Normalization
+    module Query
+      include GraphQL::Language
+
+      # query is a query string
+      def normalize(query_string)
+        document = GraphQL.parse(query_string)
+
+        # to store results
+        output = ''
+        used_fragment_names = []
+        current = {}
+        visitor = Visitor.new(document)
+
+        stack = []
+        visitor.enter << -> (_, _) do
+          stack.unshift(
+            arguments: [],
+            directives: [],
+            selections: []
+          )
+        end
+        visitor.leave << -> (_, _) { current = stack.shift }
+
+        visitor[Nodes::Argument].leave << -> (node, parent) do
+          stack[0][:arguments] << "#{node.name}:#{genericize_type(node.value)}"
+        end
+
+        visitor[Nodes::Directive].leave << -> (node, parent) do
+          id = "@#{node.name}"
+          arguments = current[:arguments]
+          unless arguments.empty?
+            id << "(#{arguments.sort.join(', ')})"
+          end
+          stack[0][:directives] << id
+        end
+
+        visitor[Nodes::Field].leave << -> (node, parent) do
+          id = node.name
+          arguments = current[:arguments]
+          unless arguments.empty?
+            id << "(#{arguments.sort.join(', ')})"
+          end
+          directives = current[:directives]
+          unless directives.empty?
+            id << " #{directives.sort.join(' ')}"
+          end
+          selections = current[:selections]
+          unless selections.empty?
+            id << ' ' + block(selections)
+          end
+
+          stack[0][:selections] << id
+        end
+
+        visitor[Nodes::InlineFragment].leave << -> (node, parent) do
+          selections = current[:selections]
+          stack[0][:selections] << "... on #{node.type} #{block(selections)}"
+        end
+
+        visitor[Nodes::FragmentSpread].leave << -> (node, parent) do
+          used_fragment_names << node.name
+          stack[0][:selections] << "...#{node.name}"
+        end
+
+        visitor[Nodes::OperationDefinition].leave << -> (node, parent) do
+          # no need to walk this, I don't think anything else can have vars
+          vars = nil
+          unless node.variables.empty?
+            variable_strs = node.variables.sort_by(&:name).map do |variable|
+              "$#{variable.name}:#{format_argument_type(variable.type)}"
+            end
+            vars = "(#{variable_strs.join(',')})"
+          end
+
+          query_content = block(current[:selections])
+          if (node.name || vars || node.operation_type != 'query')
+            parts = [node.operation_type]
+            parts << "#{node.name}#{vars}" if (node.name || vars)
+            parts << query_content
+            output << parts.join(' ')
+          else
+            output << query_content
+          end
+        end
+
+        visitor[Nodes::FragmentDefinition].leave << -> (node, parent) do
+          selections = current[:selections]
+          if (used_fragment_names.include?(node.name))
+            output << " fragment #{node.name} on #{node.type} " \
+              + block(selections)
+          end
+        end
+
+        visitor.visit
+        output
+      end
+
+      private
+
+      # See https://github.com/apollostack/optics-agent/blob/master/docs/signatures.md
+      def sort_value(a)
+        type_value = if a[0..3] == '... '
+          2
+        elsif a[0..2] == '...'
+          1
+        else
+          0
+        end
+
+        [type_value, a]
+      end
+
+      def block(array)
+        if array.empty?
+          '{}'
+        else
+          "{#{array.sort_by{ |x| sort_value(x) }.join(' ')}}"
+        end
+      end
+
+      def format_argument_type(type)
+        case type
+        when Nodes::ListType
+          "[#{format_argument_type(type.of_type)}]"
+        when Nodes::NonNullType
+          "#{format_argument_type(type.of_type)}!"
+        else
+          type.name
+        end
+      end
+
+      def genericize_type(value)
+        case value
+        when Nodes::VariableIdentifier
+          "$#{value.name}"
+        when String
+          "\"\""
+        when Numeric
+          "0"
+        when TrueClass, FalseClass
+          value.to_s
+        when Array
+          "[]"
+        when Nodes::Enum
+          value.name
+        when Nodes::InputObject
+          "{}"
+        end
+      end
+    end
+  end
+end

data/lib/optics-agent/rack-middleware.rb

@@ -0,0 +1,43 @@
+require 'optics-agent/agent'
+require 'optics-agent/reporting/query'
+
+module OpticsAgent
+  class RackMiddleware
+    def initialize(app, options={})
+      @app = app
+    end
+
+    def call(env)
+      begin
+        start_time = Time.now
+
+        # XXX: figure out a way to pass this in here
+        agent = OpticsAgent::Agent.instance
+        query = OpticsAgent::Reporting::Query.new
+
+        # Attach so resolver middleware can access
+        env[:optics_agent] = {
+          agent: agent,
+          query: query
+        }
+        env[:optics_agent].define_singleton_method(:with_document) do |document|
+          self[:query].document = document
+          self
+        end
+
+        result = @app.call(env)
+
+        # XXX: this approach means if the user forgets to call with_document
+        # we just never log queries. Can we detect if the request is a graphql one?
+        if (query.document)
+          agent.add_query(query, env, start_time, Time.now)
+        end
+
+        result
+      rescue Exception => e
+        puts "Rack Middleware Error: #{e}"
+        puts e.backtrace
+      end
+    end
+  end
+end

data/lib/optics-agent/reporting/helpers.rb

@@ -0,0 +1,32 @@
+require 'apollo/optics/proto/reports_pb'
+
+module OpticsAgent::Reporting
+  def generate_report_header
+    # XXX: fill out
+    Apollo::Optics::Proto::ReportHeader.new({
+      agent_version: '0'
+    })
+  end
+
+  def generate_timestamp(time)
+    Apollo::Optics::Proto::Timestamp.new({
+      seconds: time.to_i,
+      nanos: time.to_i % 1 * 1e9
+    });
+  end
+
+  # XXX: implement
+  def client_info(rack_env)
+    {
+      client_name: 'none',
+      client_version: 'none',
+      client_address: '::1'
+    }
+  end
+
+  def add_latency(counts, start_time, end_time)
+    micros = (end_time - start_time) * 1e6
+    bucket = latency_bucket(micros)
+    counts[bucket] += 1
+  end
+end

data/lib/optics-agent/reporting/query-trace.rb

@@ -0,0 +1,54 @@
+require 'apollo/optics/proto/reports_pb'
+require 'optics-agent/reporting/helpers'
+require 'optics-agent/reporting/send-message'
+
+module OpticsAgent::Reporting
+  # A trace is just a different view of a single query report, with full
+  # information about start and end times
+  class QueryTrace
+    include OpticsAgent::Reporting
+    include Apollo::Optics::Proto
+
+    attr_accessor :report
+
+    def initialize(query, rack_env, start_time, end_time)
+      trace = Trace.new({
+        start_time: generate_timestamp(start_time),
+        signature: query.signature
+      })
+
+      # XXX: report trace details (not totally clear yet from the JS agent what should be here)
+      trace.details = Trace::Details.new({})
+
+      info = client_info(rack_env)
+      trace.client_name = info[:client_name]
+      trace.client_version = info[:client_version]
+      trace.client_address = info[:client_address]
+      trace.http = Trace::HTTPInfo.new({
+        host: "localhost:8080",
+        path: "/graphql"
+      })
+
+      nodes = []
+      query.each_report do |type_name, field_name, field_start_time, field_end_time|
+        nodes << Trace::Node.new({
+          field_name: "#{type_name}.#{field_name}",
+          start_time: ((field_start_time - start_time) * 1e9).to_i,
+          end_time: ((field_end_time - start_time) * 1e9).to_i
+        })
+      end
+      trace.execute = Trace::Node.new({
+        child: nodes
+      })
+
+      @report = TracesReport.new({
+        header: generate_report_header,
+        trace: [trace]
+      })
+    end
+
+    def send
+      send_message('/api/ss/traces', @report)
+    end
+  end
+end

data/lib/optics-agent/reporting/query.rb

@@ -0,0 +1,65 @@
+require 'apollo/optics/proto/reports_pb'
+require 'optics-agent/reporting/helpers'
+require 'optics-agent/normalization/latency'
+
+module OpticsAgent::Reporting
+  # This is a convenience class that enables us to fairly blindly
+  # pass in data as we resolve a query
+  class Query
+    include Apollo::Optics::Proto
+    include OpticsAgent::Reporting
+    include OpticsAgent::Normalization
+
+    attr_accessor :document
+
+    def initialize
+      @reports = []
+
+      @document = nil
+    end
+
+    def signature
+      # Note this isn't actually possible but would be a sensible spot to throw
+      # if the user forgets to call `.with_document`
+      unless @document
+        throw "You must call .with_document on the optics context"
+      end
+
+      # TODO: query normalization here
+      return document["query"].to_s
+    end
+
+    # we do nothing when reporting to minimize impact
+    def report_field(type_name, field_name, start_time, end_time)
+      @reports << [type_name, field_name, start_time, end_time]
+    end
+
+    def each_report
+      @reports.each do |report|
+        yield *report
+      end
+    end
+
+    # add our results to an existing StatsPerSignature
+    def add_to_stats(stats_per_signature)
+      each_report do |type_name, field_name, start_time, end_time|
+        type_stat = stats_per_signature.per_type.find { |ts| ts.name == type_name }
+        unless type_stat
+          type_stat = TypeStat.new({ name: type_name })
+          stats_per_signature.per_type << type_stat
+        end
+
+        field_stat = type_stat.field.find { |fs| fs.name == field_name }
+        unless field_stat
+          field_stat = FieldStat.new({
+            name: field_name,
+            latency_count: empty_latency_count
+          })
+          type_stat.field << field_stat
+        end
+
+        add_latency(field_stat.latency_count, start_time, end_time)
+      end
+    end
+  end
+end

data/lib/optics-agent/reporting/report.rb

@@ -0,0 +1,102 @@
+require 'apollo/optics/proto/reports_pb'
+require 'optics-agent/reporting/send-message'
+require 'optics-agent/reporting/helpers'
+require 'optics-agent/normalization/latency'
+
+module OpticsAgent::Reporting
+  # This class represents a complete report that we send to the optics server
+  # It pretty closely wraps the StatsReport protobuf message with a few
+  # convenience methods
+  class Report
+    include Apollo::Optics::Proto
+    include OpticsAgent::Reporting
+    include OpticsAgent::Normalization
+
+    attr_accessor :report
+
+    def initialize
+      # internal report that we encapsulate
+      @report = StatsReport.new({
+        header: ReportHeader.new({
+          agent_version: '1'
+        }),
+        start_time: Timestamp.new({
+          # XXX pass this in?
+          seconds: Time.now.to_i,
+          nanos: 0
+        })
+      })
+    end
+
+    def finish!
+      @report.end_time ||= Timestamp.new({
+        # XXX pass this in?
+        seconds: Time.now.to_i,
+        nanos: 0
+      })
+    end
+
+    def send
+      self.finish!
+      send_message('/api/ss/stats', @report)
+    end
+
+    # XXX: record timing / client
+    def add_query(query, rack_env, start_time, end_time)
+      @report.per_signature[query.signature] ||= StatsPerSignature.new
+      signature_stats = @report.per_signature[query.signature]
+
+      add_client_stats(signature_stats, rack_env, start_time, end_time)
+      query.add_to_stats(signature_stats)
+    end
+
+    def add_client_stats(signature_stats, rack_env, start_time, end_time)
+      info = client_info(rack_env)
+      signature_stats.per_client_name[info[:client_name]] ||= StatsPerClientName.new({
+        latency_count: empty_latency_count,
+        error_count: empty_latency_count
+      })
+      client_stats = signature_stats.per_client_name[info[:client_name]]
+
+      # XXX: handle errors
+      add_latency(client_stats.latency_count, start_time, end_time)
+
+      client_stats.count_per_version[info[:client_version]] ||= 0
+      client_stats.count_per_version[info[:client_version]] += 1
+    end
+
+    # take a graphql schema and add returnTypes to all the fields on our report
+    def decorate_from_schema(schema)
+      each_field do |type_stat, field_stat|
+        # short circuit for special fields
+        field_stat.returnType = type_stat.name if field_stat.name == '__typename'
+
+        if type_stat.name == 'Query'
+          field_stat.returnType = '__Type' if field_stat.name == '__type'
+          field_stat.returnType = '__Schema' if field_stat.name == '__schema'
+        end
+
+        if field_stat.returnType.empty?
+          type = schema.types[type_stat.name]
+          throw "Type #{type_stat.name} not found!" unless type
+
+          field = type.fields[field_stat.name]
+          throw "Field #{type_stat.name}.#{field_stat.name} not found!" unless field
+
+          field_stat.returnType = field.type.to_s
+        end
+      end
+    end
+
+    # do something once per field we've collected
+    def each_field
+      @report.per_signature.values.each do |sps|
+        sps.per_type.each do |type|
+          type.field.each do |field|
+            yield type, field
+          end
+        end
+      end
+    end
+  end
+end