feat: Automatic schema reporting to Apollo Graph Manager

packages/apollo-engine-reporting-protobuf/src/reports.proto

@@ -270,7 +270,10 @@ message ReportHeader {
 	// eg "current", "prod"
 	string schema_tag = 10;
 	// The hex representation of the sha512 of the introspection response
-	string schema_hash = 11;
+	string deprecated_schema_hash = 11;
+
+	// An id that is used to represent the schema to Apollo Graph Manager
+	string executable_schema_id = 12;
 
 	reserved 3; // removed string service = 3;
 }

packages/apollo-engine-reporting/package.json

@@ -11,14 +11,19 @@
     "node": ">=6.0"
   },
   "dependencies": {
+    "@types/sha.js": "^2.4.0",
+    "@types/uuid": "^7.0.3",
     "apollo-engine-reporting-protobuf": "file:../apollo-engine-reporting-protobuf",
     "apollo-graphql": "^0.4.0",
+    "apollo-link": "^1.2.14",
     "apollo-server-caching": "file:../apollo-server-caching",
     "apollo-server-env": "file:../apollo-server-env",
     "apollo-server-errors": "file:../apollo-server-errors",
     "apollo-server-plugin-base": "file:../apollo-server-plugin-base",
     "apollo-server-types": "file:../apollo-server-types",
-    "async-retry": "^1.2.1"
+    "async-retry": "^1.2.1",
+    "sha.js": "^2.4.11",
+    "uuid": "^8.0.0"
   },
   "peerDependencies": {
     "graphql": "^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0"

packages/apollo-engine-reporting/src/__tests__/agent.test.ts

@@ -1,8 +1,9 @@
 import {
   signatureCacheKey,
   handleLegacyOptions,
-  EngineReportingOptions,
-} from '../agent';
+  EngineReportingOptions, computeExecutableSchemaId
+} from "../agent";
+import { buildSchema } from "graphql";
 
 describe('signature cache key', () => {
   it('generates without the operationName', () => {
@@ -16,6 +17,59 @@ describe('signature cache key', () => {
   });
 });
 
+describe('Executable Schema Id', () => {
+  const unsortedGQLSchemaDocument = `
+      directive @example on FIELD
+      union AccountOrUser = Account | User
+      type Query {
+        userOrAccount(name: String, id: String): AccountOrUser
+      }
+
+      type User {
+        accounts: [Account!]
+        email: String
+        name: String!
+      }
+
+      type Account {
+        name: String!
+        id: ID!
+      }
+    `;
+
+  const sortedGQLSchemaDocument = `
+      directive @example on FIELD
+      union AccountOrUser = Account | User
+
+      type Account {
+        name: String!
+        id: ID!
+      }
+
+      type Query {
+        userOrAccount(id: String, name: String): AccountOrUser
+      }
+
+      type User {
+        accounts: [Account!]
+        email: String
+        name: String!
+      }
+
+    `;
+  it('to be normalized for graphql schemas', () => {
+    expect(computeExecutableSchemaId(buildSchema(unsortedGQLSchemaDocument))).toEqual(
+      computeExecutableSchemaId(buildSchema(sortedGQLSchemaDocument))
+    );
+  });
+  it('to not be normalized for strings', () => {
+    expect(computeExecutableSchemaId(unsortedGQLSchemaDocument)).not.toEqual(
+      computeExecutableSchemaId(sortedGQLSchemaDocument)
+    );
+  });
+});
+
+
 describe("test handleLegacyOptions(), which converts the deprecated privateVariable and privateHeaders options to the new options' formats", () => {
   it('Case 1: privateVariables/privateHeaders == False; same as all', () => {
     const optionsPrivateFalse: EngineReportingOptions<any> = {

packages/apollo-engine-reporting/src/__tests__/plugin.test.ts

@@ -1,14 +1,22 @@
 import { makeExecutableSchema, addMockFunctionsToSchema } from 'graphql-tools';
-import { graphql, GraphQLError } from 'graphql';
+import {
+  graphql,
+  GraphQLError,
+  GraphQLSchema,
+  lexicographicSortSchema,
+  printSchema,
+  stripIgnoredCharacters,
+} from 'graphql';
 import { Request } from 'node-fetch';
 import { makeTraceDetails, makeHTTPRequestHeaders, plugin } from '../plugin';
 import { Headers } from 'apollo-server-env';
-import { AddTraceArgs } from '../agent';
+import { AddTraceArgs, computeExecutableSchemaId } from "../agent";
 import { Trace } from 'apollo-engine-reporting-protobuf';
 import pluginTestHarness from 'apollo-server-core/dist/utils/pluginTestHarness';
+import { sha256 } from 'sha.js';
+import { isString } from 'util';
 
-it('trace construction', async () => {
-  const typeDefs = `
+const typeDefs = `
   type User {
     id: Int
     name: String
@@ -31,7 +39,7 @@ it('trace construction', async () => {
   }
 `;
 
-  const query = `
+const query = `
     query q {
       author(id: 5) {
         name
@@ -43,17 +51,166 @@ it('trace construction', async () => {
     }
 `;
 
+describe('schema reporting', () => {
+  const schema = makeExecutableSchema({ typeDefs });
+  addMockFunctionsToSchema({ schema });
+
+  const addTrace = jest.fn();
+  const startSchemaReporting = jest.fn();
+  const executableSchemaIdGenerator = jest.fn(computeExecutableSchemaId);
+
+  beforeEach(() => {
+    addTrace.mockClear();
+    startSchemaReporting.mockClear();
+    executableSchemaIdGenerator.mockClear();
+  });
+
+  it('starts reporing if enabled', async () => {
+    const pluginInstance = plugin(
+      {
+        experimental_schemaReporting: true,
+      },
+      addTrace,
+      startSchemaReporting,
+      executableSchemaIdGenerator,
+    );
+
+    await pluginTestHarness({
+      pluginInstance,
+      schema,
+      graphqlRequest: {
+        query,
+        operationName: 'q',
+        extensions: {
+          clientName: 'testing suite',
+        },
+        http: new Request('http://localhost:123/foo'),
+      },
+      executor: async ({ request: { query: source } }) => {
+        return await graphql({
+          schema,
+          source,
+        });
+      },
+    });
+
+    expect(startSchemaReporting).toBeCalledTimes(1);
+    expect(startSchemaReporting).toBeCalledWith({
+      executableSchema: printSchema(schema),
+      executableSchemaId: executableSchemaIdGenerator(schema),
+    });
+  });
+
+  it('uses the override schema', async () => {
+    const pluginInstance = plugin(
+      {
+        experimental_schemaReporting: true,
+        experimental_overrideReportedSchema: typeDefs,
+      },
+      addTrace,
+      startSchemaReporting,
+      executableSchemaIdGenerator,
+    );
+
+    await pluginTestHarness({
+      pluginInstance,
+      schema,
+      graphqlRequest: {
+        query,
+        operationName: 'q',
+        extensions: {
+          clientName: 'testing suite',
+        },
+        http: new Request('http://localhost:123/foo'),
+      },
+      executor: async ({ request: { query: source } }) => {
+        return await graphql({
+          schema,
+          source,
+        });
+      },
+    });
+
+    const expectedExecutableSchemaId = executableSchemaIdGenerator(typeDefs);
+    expect(startSchemaReporting).toBeCalledTimes(1);
+    expect(startSchemaReporting).toBeCalledWith({
+      executableSchema: typeDefs,
+      executableSchemaId: expectedExecutableSchemaId,
+    });
+
+    // Get the first argument from the first time this is called.
+    // Not using called with because that has to be exhaustive and this isn't
+    // testing trace generation
+    expect(addTrace.mock.calls[0][0].executableSchemaId).toBe(
+      expectedExecutableSchemaId,
+    );
+  });
+
+  it('uses the same executable schema id for metric reporting', async () => {
+    const pluginInstance = plugin(
+      {
+        experimental_schemaReporting: true,
+      },
+      addTrace,
+      startSchemaReporting,
+      executableSchemaIdGenerator,
+    );
+
+    await pluginTestHarness({
+      pluginInstance,
+      schema,
+      graphqlRequest: {
+        query,
+        operationName: 'q',
+        extensions: {
+          clientName: 'testing suite',
+        },
+        http: new Request('http://localhost:123/foo'),
+      },
+      executor: async ({ request: { query: source } }) => {
+        return await graphql({
+          schema,
+          source,
+        });
+      },
+    });
+
+    const expectedExecutableSchemaId = executableSchemaIdGenerator(schema);
+    expect(startSchemaReporting).toBeCalledTimes(1);
+    expect(startSchemaReporting).toBeCalledWith({
+      executableSchema: printSchema(schema),
+      executableSchemaId: expectedExecutableSchemaId,
+    });
+    // Get the first argument from the first time this is called.
+    // Not using called with because that has to be exhaustive and this isn't
+    // testing trace generation
+    expect(addTrace.mock.calls[0][0].executableSchemaId).toBe(
+      expectedExecutableSchemaId,
+    );
+  });
+});
+
+it('trace construction', async () => {
   const schema = makeExecutableSchema({ typeDefs });
   addMockFunctionsToSchema({ schema });
 
   const traces: Array<AddTraceArgs> = [];
   async function addTrace(args: AddTraceArgs) {
     traces.push(args);
   }
+  const startSchemaReporting = jest.fn();
+  const executableSchemaIdGenerator = jest.fn();
 
-  const pluginInstance = plugin({ /* no options!*/ }, addTrace);
+  const pluginInstance = plugin(
+    {
+      /* no options!*/
+    },
+    addTrace,
+    startSchemaReporting,
+    executableSchemaIdGenerator,
+  );
 
-  pluginTestHarness({
+  await pluginTestHarness({
     pluginInstance,
     schema,
     graphqlRequest: {
@@ -260,7 +417,7 @@ describe('variableJson output for sendVariableValues transform: custom function
     ).toEqual(JSON.stringify(null));
   });
 
-  const errorThrowingModifier = (input: {
+  const errorThrowingModifier = (_input: {
     variables: Record<string, any>;
   }): Record<string, any> => {
     throw new GraphQLError('testing error handling');