optics-agent 0.1.0

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

@@ -0,0 +1,24 @@
+require 'sucker_punch'
+require 'optics-agent/reporting/report'
+
+module OpticsAgent::Reporting
+  class ReportJob
+    include SuckerPunch::Job
+
+    def perform(agent)
+      report = OpticsAgent::Reporting::Report.new
+      agent.clear_query_queue.each do |item|
+        report.add_query(*item)
+
+        # XXX: don't send *every* trace
+        query_trace = QueryTrace.new(*item)
+        query_trace.send
+      end
+
+      report.decorate_from_schema(agent.schema)
+      report.send
+
+      self.class.perform_in(60, agent)
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require 'json'
+require 'graphql'
+
+require 'apollo/optics/proto/reports_pb'
+require 'optics-agent/reporting/helpers'
+require 'optics-agent/reporting/send-message'
+require 'optics-agent/instrumentation/query-schema'
+
+module OpticsAgent::Reporting
+  # A report for a whole schema
+  class Schema
+    include Apollo::Optics::Proto
+    include OpticsAgent::Instrumentation
+    include OpticsAgent::Reporting
+
+    attr_accessor :message
+
+    def initialize(schema)
+      @message = SchemaReport.new({
+        header: generate_report_header(),
+        introspection_result: JSON.generate(introspect_schema(schema)),
+        type: get_types(schema)
+      })
+    end
+
+    # construct an array of Type (protobuf) objects
+    def get_types(schema)
+      types = []
+
+      schema.types.keys.each do |type_name|
+        next if type_name =~ /^__/
+        type = schema.types[type_name]
+        next unless type.is_a? GraphQL::ObjectType
+
+        fields = type.fields.values.map do |field|
+          Field.new({
+            name: field.name,
+            # XXX: does this actually work for all types?
+            returnType: field.type.to_s
+          })
+        end
+
+        types << Type.new({
+          name: type_name,
+          field: fields
+        })
+      end
+
+      types
+    end
+
+    def send
+      send_message('/api/ss/schema', @message)
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'sucker_punch'
+require 'optics-agent/reporting/schema'
+
+module OpticsAgent::Reporting
+  class SchemaJob
+    include SuckerPunch::Job
+
+    def perform(agent)
+      puts 'performing schema job'
+      schema = OpticsAgent::Reporting::Schema.new agent.schema
+      schema.send
+    end
+  end
+end

data/lib/optics-agent/reporting/send-message.rb

@@ -0,0 +1,23 @@
+require 'net/http'
+
+module OpticsAgent
+  module Reporting
+    OPTICS_URL = 'https://optics-report.apollodata.com'
+    def send_message(path, message)
+
+      req = Net::HTTP::Post.new(path)
+      req['x-api-key'] = ENV['OPTICS_API_KEY']
+      req['user-agent'] = "optics-agent-rb"
+
+      req.body = message.class.encode(message)
+      puts message.class.encode_json(message)
+
+      uri = URI.parse(OPTICS_URL)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      res = http.request(req)
+      p res
+      p res.body
+    end
+  end
+end

data/spec/graphql-middleware_spec.rb

@@ -0,0 +1,46 @@
+require 'optics-agent/graphql-middleware'
+require 'graphql'
+
+include OpticsAgent
+
+describe GraphqlMiddleware do
+  it 'collects the correct query stats' do
+    person_type = GraphQL::ObjectType.define do
+      name "Person"
+      field :firstName do
+        type types.String
+        resolve -> (obj, args, ctx) { sleep(0.100); return 'Tom' }
+      end
+      field :lastName do
+        type types.String
+        resolve -> (obj, args, ctx) { sleep(0.100); return 'Coleman' }
+      end
+    end
+    query_type = GraphQL::ObjectType.define do
+      name 'Query'
+      field :person do
+        type person_type
+        resolve -> (obj, args, ctx) { sleep(0.050); return {} }
+      end
+    end
+
+    schema = GraphQL::Schema.define do
+      query query_type
+    end
+
+    schema.middleware << GraphqlMiddleware.new
+
+    query = spy("query")
+    schema.execute('{ person { firstName lastName } }', {
+      context: { optics_agent: { query: query } }
+    })
+
+    expect(query).to have_received(:report_field).exactly(3).times
+    expect(query).to have_received(:report_field)
+      .with('Query', 'person', be_instance_of(Time), be_instance_of(Time))
+    expect(query).to have_received(:report_field)
+      .with('Person', 'firstName', be_instance_of(Time), be_instance_of(Time))
+    expect(query).to have_received(:report_field)
+      .with('Person', 'lastName', be_instance_of(Time), be_instance_of(Time))
+  end
+end

data/spec/latency_spec.rb

@@ -0,0 +1,34 @@
+require 'optics-agent/normalization/latency'
+include OpticsAgent::Normalization
+
+
+describe 'latency helpers' do
+  describe 'empty_latency_count' do
+    it 'returns 256 zeros' do
+      zeros = empty_latency_count
+      expect(zeros.length).to equal(256)
+      zeros.each { |z| expect(z).to eq(0) }
+    end
+  end
+
+  describe 'latency_bucket' do
+    it 'returns the right values' do
+      tests = [
+        [0.1, 0],
+        [0.9, 0],
+        [1, 0],
+        [1.1, 1],
+        [1.21, 2],
+        [100, 49],
+        [1000, 73],
+        [1000 * 1000, 145],
+        [1.1**254, 255],
+        [1000 * 1000 * 1000 * 1000, 255]
+      ]
+
+      tests.each do |test|
+        expect(latency_bucket test.first).to eq(test.last)
+      end
+    end
+  end
+end

data/spec/query-normalization_spec.rb

@@ -0,0 +1,105 @@
+require 'optics-agent/normalization/query'
+
+TEST_QUERIES = [
+  [
+    'basic test',
+    '{
+      user {
+        name
+      }
+    }',
+    '{user {name}}',
+  ],
+  [
+    'basic test with query',
+    'query {
+      user {
+        name
+      }
+    }',
+    '{user {name}}',
+  ],
+  [
+    'basic with operation name',
+    'query OpName {
+      user {
+        name
+      }
+    }',
+    'query OpName {user {name}}',
+  ],
+  [
+    'with various inline types',
+    'query OpName {
+      user {
+        name(apple: [[10]], cat: ENUM_VALUE, bag: {input: "value"})
+      }
+    }',
+    'query OpName {user {name(apple:[], bag:{}, cat:ENUM_VALUE)}}',
+  ],
+  [
+    'with various argument types',
+    'query OpName($c: Int!, $a: [[Boolean!]!], $b: EnumType) {
+      user {
+        name(apple: $a, cat: $c, bag: $b)
+      }
+    }',
+    'query OpName($a:[[Boolean!]!],$b:EnumType,$c:Int!) {user {name(apple:$a, bag:$b, cat:$c)}}',
+  ],
+  [
+    'fragment',
+    '{
+      user {
+        name
+        ...Bar
+      }
+    }
+    fragment Bar on User {
+      asd
+    }
+    fragment Baz on User {
+      jkl
+    }',
+    '{user {name ...Bar}} fragment Bar on User {asd}',
+  ],
+  [
+    'full test',
+    'query Foo ($b: Int, $a: Boolean){
+      user(name: "hello", age: 5) {
+        ... Bar
+        ... on User {
+          hello
+          bee
+        }
+        tz
+        aliased: name
+      }
+    }
+    fragment Baz on User {
+      asd
+    }
+    fragment Bar on User {
+      age @skip(if: $a)
+      ...Nested
+    }
+    fragment Nested on User {
+      blah
+    }',
+    'query Foo($a:Boolean,$b:Int) {user(age:0, name:"") {name tz ...Bar ... on User {bee hello}}}' +
+    ' fragment Bar on User {age @skip(if:$a) ...Nested} fragment Nested on User {blah}',
+  ],
+]
+
+
+describe OpticsAgent::Normalization::Query do
+  include OpticsAgent::Normalization::Query
+
+  TEST_QUERIES.each do |spec|
+    test_name, query, expected_signature = spec
+
+    it test_name do
+      signature = normalize(query)
+      expect(signature).to eq(expected_signature)
+    end
+  end
+end

data/spec/query_trace_spec.rb

@@ -0,0 +1,43 @@
+require 'optics-agent/reporting/query-trace'
+require 'optics-agent/reporting/query'
+require 'apollo/optics/proto/reports_pb'
+require 'graphql'
+
+include Apollo::Optics::Proto
+include OpticsAgent::Reporting
+
+class DocumentMock
+  def initialize(key)
+    @key = key
+  end
+
+  def [](name) # used for [:query]
+    @key
+  end
+end
+
+
+describe QueryTrace do
+  it "can represent a simple query" do
+    query = Query.new
+    query.report_field 'Person', 'firstName', 1, 1.1
+    query.report_field 'Person', 'lastName', 1, 1.1
+    query.report_field 'Query', 'person', 1, 1.22
+    query.document = DocumentMock.new('key')
+
+    trace = QueryTrace.new(query, {}, 1, 1.25)
+
+    expect(trace.report).to be_instance_of(TracesReport)
+    expect(trace.report.trace.length).to eq(1)
+
+    trace_obj = trace.report.trace.first
+    nodes = trace_obj.execute.child
+    expect(nodes.length).to eq(3)
+    expect(nodes.map(&:field_name)).to \
+      match_array(['Query.person', 'Person.firstName', 'Person.lastName'])
+
+    firstName_node = nodes.find { |n| n.field_name == 'Person.firstName' }
+    expect(firstName_node.start_time).to eq(0)
+    expect(firstName_node.end_time).to eq(0.1 * 1e9)
+  end
+end

data/spec/report_spec.rb

@@ -0,0 +1,194 @@
+require 'optics-agent/reporting/report'
+require 'optics-agent/reporting/query'
+require 'apollo/optics/proto/reports_pb'
+require 'graphql'
+
+include OpticsAgent::Reporting
+include Apollo::Optics::Proto
+
+class DocumentMock
+  def initialize(key)
+    @key = key
+  end
+
+  def [](name) # used for [:query]
+    @key
+  end
+end
+
+
+describe Report do
+  it "can represent a simple query" do
+    query = Query.new
+    query.report_field 'Person', 'firstName', 1, 1.1
+    query.report_field 'Person', 'lastName', 1, 1.1
+    query.report_field 'Query', 'person', 1, 1.22
+    query.document = DocumentMock.new('key')
+
+    report = Report.new
+    report.add_query query, {}, 1, 1.25
+    report.finish!
+
+    expect(report.report).to be_an_instance_of(StatsReport)
+    stats_report = report.report
+    expect(stats_report.per_signature.keys).to match_array(['key'])
+
+    signature_stats = stats_report.per_signature.values.first
+    expect(signature_stats.per_type.length).to equal(2)
+    expect(signature_stats.per_type.map &:name).to match_array(['Person', 'Query'])
+
+    person_stats = signature_stats.per_type.find { |s| s.name === 'Person' }
+    expect(person_stats.field.length).to equal(2)
+    expect(person_stats.field.map &:name).to match_array(['firstName', 'lastName'])
+
+    firstName_stats = person_stats.field.find { |s| s.name === 'firstName' }
+    expect(firstName_stats.latency_count.length).to eq(256)
+    expect(firstName_stats.latency_count.reduce(&:+)).to eq(1)
+    expect(firstName_stats.latency_count[121]).to eq(1)
+  end
+
+  it "can aggregate the results of multiple queries with the same shape" do
+    queryOne = Query.new
+    queryOne.report_field 'Person', 'firstName', 1, 1.1
+    queryOne.report_field 'Person', 'lastName', 1, 1.1
+    queryOne.report_field 'Query', 'person', 1, 1.22
+    queryOne.document = DocumentMock.new('key')
+
+    queryTwo = Query.new
+    queryTwo.report_field 'Person', 'firstName', 1, 1.05
+    queryTwo.report_field 'Person', 'lastName', 1, 1.05
+    queryTwo.report_field 'Query', 'person', 1, 1.2
+    queryTwo.document = DocumentMock.new('key')
+
+    report = Report.new
+    report.add_query queryOne, {}, 1, 1.1
+    report.add_query queryTwo, {}, 1, 1.1
+    report.finish!
+
+    expect(report.report).to be_an_instance_of(StatsReport)
+    stats_report = report.report
+    expect(stats_report.per_signature.keys).to match_array(['key'])
+
+    signature_stats = stats_report.per_signature.values.first
+    expect(signature_stats.per_type.length).to equal(2)
+    expect(signature_stats.per_type.map &:name).to match_array(['Person', 'Query'])
+
+    person_stats = signature_stats.per_type.find { |s| s.name === 'Person' }
+    expect(person_stats.field.length).to equal(2)
+    expect(person_stats.field.map &:name).to match_array(['firstName', 'lastName'])
+
+    firstName_stats = person_stats.field.find { |s| s.name === 'firstName' }
+    expect(firstName_stats.latency_count.reduce(&:+)).to eq(2)
+    expect(firstName_stats.latency_count[114]).to eq(1)
+    expect(firstName_stats.latency_count[121]).to eq(1)
+  end
+
+  it "can aggregate the results of multiple queries with a different shape" do
+    queryOne = Query.new
+    queryOne.report_field 'Person', 'firstName', 1, 1.1
+    queryOne.report_field 'Person', 'lastName', 1, 1.1
+    queryOne.report_field 'Query', 'person', 1, 1.22
+    queryOne.document = DocumentMock.new('keyOne')
+
+    queryTwo = Query.new
+    queryTwo.report_field 'Person', 'firstName', 1, 1.05
+    queryTwo.report_field 'Person', 'lastName', 1, 1.05
+    queryTwo.report_field 'Query', 'person', 1, 1.02
+    queryTwo.document = DocumentMock.new('keyTwo')
+
+    report = Report.new
+    report.add_query queryOne, {}, 1, 1.1
+    report.add_query queryTwo, {}, 1, 1.1
+    report.finish!
+
+    expect(report.report).to be_an_instance_of(StatsReport)
+    stats_report = report.report
+    expect(stats_report.per_signature.keys).to match_array(['keyOne', 'keyTwo'])
+
+    signature_stats = stats_report.per_signature['keyOne']
+    expect(signature_stats.per_type.length).to equal(2)
+    expect(signature_stats.per_type.map &:name).to match_array(['Person', 'Query'])
+
+    person_stats = signature_stats.per_type.find { |s| s.name === 'Person' }
+    expect(person_stats.field.length).to equal(2)
+    expect(person_stats.field.map &:name).to match_array(['firstName', 'lastName'])
+
+    firstName_stats = person_stats.field.find { |s| s.name === 'firstName' }
+    expect(firstName_stats.latency_count.reduce(&:+)).to eq(1)
+    expect(firstName_stats.latency_count[121]).to eq(1)
+  end
+
+
+  it "can decorate it's fields with resultTypes from a schema" do
+    query = Query.new
+    query.report_field 'Person', 'firstName', 1, 1.1
+    query.report_field 'Person', 'age', 1, 1.1
+    query.document = DocumentMock.new('key')
+
+    report = Report.new
+    report.add_query query, {}, 1, 1.25
+    report.finish!
+
+    person_type = GraphQL::ObjectType.define do
+      name 'Person'
+      field :firstName, types.String
+      field :age, !types.Int
+    end
+    query_type = GraphQL::ObjectType.define do
+      name 'Query'
+      field :person, person_type
+    end
+
+    schema = GraphQL::Schema.define do
+      query query_type
+    end
+
+    report.decorate_from_schema(schema)
+
+    stats_report = report.report
+    signature_stats = stats_report.per_signature.values.first
+    person_stats = signature_stats.per_type.find { |s| s.name === 'Person' }
+
+    firstName_stats = person_stats.field.find { |s| s.name === 'firstName' }
+    expect(firstName_stats.returnType).to eq('String')
+
+    age_stats = person_stats.field.find { |s| s.name === 'age' }
+    expect(age_stats.returnType).to eq('Int!')
+  end
+
+  it "can handle introspection fields" do
+    query = Query.new
+    query.report_field 'Query', '__schema', 1, 1.1
+    query.report_field 'Query', '__typename', 1, 1.1
+    query.report_field 'Query', '__type', 1, 1.1
+    query.document = DocumentMock.new('key')
+
+    report = Report.new
+    report.add_query query, {}, 1, 1.25
+    report.finish!
+
+    query_type = GraphQL::ObjectType.define do
+      name 'Query'
+    end
+
+    schema = GraphQL::Schema.define do
+      query query_type
+    end
+
+    report.decorate_from_schema(schema)
+
+    stats_report = report.report
+    signature_stats = stats_report.per_signature.values.first
+    query_stats = signature_stats.per_type.find { |s| s.name === 'Query' }
+
+    schema_stats = query_stats.field.find { |s| s.name === '__schema' }
+    expect(schema_stats.returnType).to eq('__Schema')
+
+    type_stats = query_stats.field.find { |s| s.name === '__type' }
+    expect(type_stats.returnType).to eq('__Type')
+
+    typename_stats = query_stats.field.find { |s| s.name === '__typename' }
+    expect(typename_stats.returnType).to eq('Query')
+  end
+
+end