diff --git a/packages/compass-schema/src/components/compass-schema.tsx b/packages/compass-schema/src/components/compass-schema.tsx
index b8f930b8e8d..b2a742d5107 100644
--- a/packages/compass-schema/src/components/compass-schema.tsx
+++ b/packages/compass-schema/src/components/compass-schema.tsx
@@ -446,7 +446,7 @@ export default connect(
   }),
   {
     onStartAnalysis: startAnalysis,
-    onStopAnalysis: stopAnalysis,
+    onStopAnalysis: () => stopAnalysis(),
     onExportSchemaClicked: openExportSchema,
   }
 )(Schema);
diff --git a/packages/compass-schema/src/components/export-schema-legacy-banner.tsx b/packages/compass-schema/src/components/export-schema-legacy-banner.tsx
index f46e3ed3779..71415ac892b 100644
--- a/packages/compass-schema/src/components/export-schema-legacy-banner.tsx
+++ b/packages/compass-schema/src/components/export-schema-legacy-banner.tsx
@@ -13,7 +13,7 @@ import {
 
 import type { RootState, SchemaThunkDispatch } from '../stores/store';
 import {
-  confirmedLegacySchemaShare,
+  confirmedExportLegacySchemaToClipboard,
   switchToSchemaExport,
   SchemaExportActions,
   stopShowingLegacyBanner,
@@ -539,7 +539,7 @@ export default connect(
   }),
   (dispatch: SchemaThunkDispatch) => ({
     onClose: () => dispatch({ type: SchemaExportActions.closeLegacyBanner }),
-    onLegacyShare: () => dispatch(confirmedLegacySchemaShare()),
+    onLegacyShare: () => dispatch(confirmedExportLegacySchemaToClipboard()),
     onSwitchToSchemaExport: () => dispatch(switchToSchemaExport()),
     stopShowingLegacyBanner: (choice: 'legacy' | 'export') =>
       dispatch(stopShowingLegacyBanner(choice)),
diff --git a/packages/compass-schema/src/components/export-schema-modal.tsx b/packages/compass-schema/src/components/export-schema-modal.tsx
index 1148a0e8435..08768eea7fb 100644
--- a/packages/compass-schema/src/components/export-schema-modal.tsx
+++ b/packages/compass-schema/src/components/export-schema-modal.tsx
@@ -21,6 +21,7 @@ import {
   cancelExportSchema,
   changeExportSchemaFormat,
   closeExportSchema,
+  trackSchemaExported,
   type SchemaFormat,
   type ExportStatus,
 } from '../stores/schema-export-reducer';
@@ -75,6 +76,7 @@ const ExportSchemaModal: React.FunctionComponent<{
   onCancelSchemaExport: () => void;
   onChangeSchemaExportFormat: (format: SchemaFormat) => Promise<void>;
   onClose: () => void;
+  onExportedSchemaCopied: () => void;
 }> = ({
   errorMessage,
   exportStatus,
@@ -84,6 +86,7 @@ const ExportSchemaModal: React.FunctionComponent<{
   onCancelSchemaExport,
   onChangeSchemaExportFormat,
   onClose,
+  onExportedSchemaCopied,
 }) => {
   const onFormatOptionSelected = useCallback(
     (event: ChangeEvent<HTMLInputElement>) => {
@@ -143,6 +146,7 @@ const ExportSchemaModal: React.FunctionComponent<{
               language="json"
               className={codeStyles}
               copyable={true}
+              onCopy={onExportedSchemaCopied}
             >
               {exportedSchema ?? 'Empty'}
             </Code>
@@ -163,7 +167,7 @@ const ExportSchemaModal: React.FunctionComponent<{
         </Button>
         <Button
           onClick={() => {
-            /* TODO(COMPASS-8704) */
+            /* TODO(COMPASS-8704): download and track with trackSchemaExported */
           }}
           variant="primary"
         >
@@ -183,6 +187,7 @@ export default connect(
     exportedSchema: state.schemaExport.exportedSchema,
   }),
   {
+    onExportedSchemaCopied: trackSchemaExported,
     onCancelSchemaExport: cancelExportSchema,
     onChangeSchemaExportFormat: changeExportSchemaFormat,
     onClose: closeExportSchema,
diff --git a/packages/compass-schema/src/modules/schema-analysis.spec.ts b/packages/compass-schema/src/modules/schema-analysis.spec.ts
index 04b7b90d88e..2e6696a65f4 100644
--- a/packages/compass-schema/src/modules/schema-analysis.spec.ts
+++ b/packages/compass-schema/src/modules/schema-analysis.spec.ts
@@ -6,11 +6,7 @@ import type { Schema } from 'mongodb-schema';
 import { createNoopLogger } from '@mongodb-js/compass-logging/provider';
 import { isInternalFieldPath } from 'hadron-document';
 
-import {
-  analyzeSchema,
-  calculateSchemaDepth,
-  schemaContainsGeoData,
-} from './schema-analysis';
+import { analyzeSchema, calculateSchemaMetadata } from './schema-analysis';
 
 const testDocs = [
   {
@@ -250,164 +246,396 @@ describe('schema-analysis', function () {
     });
   });
 
-  describe('#calculateSchemaDepth', function () {
-    describe('with an empty schema', function () {
-      let schema: Schema;
-      before(async function () {
-        schema = await mongoDBSchemaAnalyzeSchema([{}]);
+  describe('#calculateSchemaMetadata', function () {
+    describe('schema_depth', function () {
+      describe('with an empty schema', function () {
+        let schema: Schema;
+        before(async function () {
+          schema = await mongoDBSchemaAnalyzeSchema([{}]);
+        });
+
+        it('has a depth of 0', async function () {
+          const { schema_depth } = await calculateSchemaMetadata(schema);
+          expect(schema_depth).to.equal(0);
+        });
       });
 
-      it('has a depth of 0', function () {
-        expect(calculateSchemaDepth(schema)).to.equal(0);
+      describe('with a basic schema', function () {
+        let schema: Schema;
+        before(async function () {
+          schema = await mongoDBSchemaAnalyzeSchema([
+            {
+              someFields: {
+                pineapple: 25,
+              },
+              ok: 'nice',
+            },
+          ]);
+        });
+
+        it('has a depth of 2', async function () {
+          const { schema_depth } = await calculateSchemaMetadata(schema);
+          expect(schema_depth).to.equal(2);
+        });
       });
-    });
 
-    describe('with a basic schema', function () {
-      let schema: Schema;
-      before(async function () {
-        schema = await mongoDBSchemaAnalyzeSchema([
-          {
-            someFields: {
-              pineapple: 25,
+      describe('with complex schema with different document depths', function () {
+        let schema: Schema;
+        before(async function () {
+          schema = await mongoDBSchemaAnalyzeSchema(testDocs);
+        });
+
+        it('has the correct depth', async function () {
+          const { schema_depth } = await calculateSchemaMetadata(schema);
+          expect(schema_depth).to.equal(8);
+        });
+      });
+
+      describe('with a basic array', function () {
+        let schema: Schema;
+        before(async function () {
+          schema = await mongoDBSchemaAnalyzeSchema([
+            {
+              arrayField: [1, 2, 3],
             },
-            ok: 'nice',
-          },
-        ]);
+          ]);
+        });
+
+        it('has a depth of two', async function () {
+          const { schema_depth } = await calculateSchemaMetadata(schema);
+          expect(schema_depth).to.equal(2);
+        });
       });
 
-      it('has a depth of 2', function () {
-        expect(calculateSchemaDepth(schema)).to.equal(2);
+      describe('with nested arrays', function () {
+        let schema: Schema;
+        before(async function () {
+          schema = await mongoDBSchemaAnalyzeSchema([
+            {
+              arrayField: [[[['a']]]],
+            },
+          ]);
+        });
+
+        it('has the correct depth', async function () {
+          const { schema_depth } = await calculateSchemaMetadata(schema);
+          expect(schema_depth).to.equal(5);
+        });
       });
     });
 
-    describe('with complex schema with different document depths', function () {
-      let schema: Schema;
-      before(async function () {
-        schema = await mongoDBSchemaAnalyzeSchema(testDocs);
+    describe('geo_data', function () {
+      describe('with an empty schema', function () {
+        let schema: Schema;
+        before(async function () {
+          schema = await mongoDBSchemaAnalyzeSchema([{}]);
+        });
+
+        it('returns false', async function () {
+          const { geo_data } = await calculateSchemaMetadata(schema);
+          expect(geo_data).to.equal(false);
+        });
       });
 
-      it('has the correct depth', function () {
-        expect(calculateSchemaDepth(schema)).to.equal(8);
+      describe('with a basic document without geo data', function () {
+        let schema: Schema;
+        before(async function () {
+          schema = await mongoDBSchemaAnalyzeSchema([
+            {
+              fruits: {
+                pineapple: 'yes',
+                apples: ['golden', 'fiji'],
+              },
+            },
+          ]);
+        });
+
+        it('does not detect geo data', async function () {
+          const { geo_data } = await calculateSchemaMetadata(schema);
+          expect(geo_data).to.equal(false);
+        });
       });
-    });
 
-    describe('with a basic array', function () {
-      let schema: Schema;
-      before(async function () {
-        schema = await mongoDBSchemaAnalyzeSchema([
-          {
-            arrayField: [1, 2, 3],
-          },
-        ]);
+      describe('with more complex documents without geo data', function () {
+        let schema: Schema;
+        before(async function () {
+          schema = await mongoDBSchemaAnalyzeSchema(testDocs);
+        });
+
+        it('does not detect geo data', async function () {
+          const { geo_data } = await calculateSchemaMetadata(schema);
+          expect(geo_data).to.equal(false);
+        });
       });
 
-      it('has a depth of two', function () {
-        expect(calculateSchemaDepth(schema)).to.equal(2);
+      describe('with a basic document with Point geo data', function () {
+        let schema: Schema;
+        before(async function () {
+          schema = await mongoDBSchemaAnalyzeSchema([
+            {
+              name: 'somewhere',
+              location: {
+                type: 'Point',
+                coordinates: [-73.856077, 40.848447],
+              },
+            },
+          ]);
+        });
+
+        it('detects geo data', async function () {
+          const { geo_data } = await calculateSchemaMetadata(schema);
+          expect(geo_data).to.equal(true);
+        });
+      });
+
+      describe('with Polygon geo data', function () {
+        let schema: Schema;
+        before(async function () {
+          schema = await mongoDBSchemaAnalyzeSchema([
+            {
+              type: 'geojson',
+              data: {
+                type: 'Feature',
+                geometry: {
+                  type: 'Polygon',
+                  coordinates: [
+                    [
+                      [-73.856077, 40.848447],
+                      [-72.856077, 41.848447],
+                      [-73.856077, 41.848447],
+                      [-72.856077, 40.848447],
+                    ],
+                  ],
+                },
+              },
+            },
+          ]);
+        });
+
+        it('detects geo data', async function () {
+          const { geo_data } = await calculateSchemaMetadata(schema);
+          expect(geo_data).to.equal(true);
+        });
       });
     });
 
-    describe('with nested arrays', function () {
-      let schema: Schema;
-      before(async function () {
-        schema = await mongoDBSchemaAnalyzeSchema([
-          {
-            arrayField: [[[['a']]]],
-          },
-        ]);
+    describe('variable_type_count', function () {
+      describe('with fields having multiple types', function () {
+        let schema: Schema;
+        before(async function () {
+          schema = await mongoDBSchemaAnalyzeSchema([
+            { pineapple: 123 },
+            { pineapple: 'string' },
+            { pineapple: true },
+            { singleType: 'onlyString' },
+          ]);
+        });
+
+        it('counts fields with more than one type', async function () {
+          const { variable_type_count } = await calculateSchemaMetadata(schema);
+          expect(variable_type_count).to.equal(1);
+        });
       });
 
-      it('has the correct depth', function () {
-        expect(calculateSchemaDepth(schema)).to.equal(5);
+      describe('with no fields', function () {
+        let schema: Schema;
+        before(async function () {
+          schema = await mongoDBSchemaAnalyzeSchema([{}]);
+        });
+
+        it('returns zero', async function () {
+          const { variable_type_count } = await calculateSchemaMetadata(schema);
+          expect(variable_type_count).to.equal(0);
+        });
       });
-    });
-  });
 
-  describe('#schemaContainsGeoData', function () {
-    describe('with an empty schema', function () {
-      let schema: Schema;
-      before(async function () {
-        schema = await mongoDBSchemaAnalyzeSchema([{}]);
+      describe('with all single-type fields', function () {
+        let schema: Schema;
+        before(async function () {
+          schema = await mongoDBSchemaAnalyzeSchema([
+            { a: 1 },
+            { a: 2, b: 2 },
+            { a: 2, c: 3 },
+          ]);
+        });
+
+        it('returns zero', async function () {
+          const { variable_type_count } = await calculateSchemaMetadata(schema);
+          expect(variable_type_count).to.equal(0);
+        });
       });
 
-      it('returns false', function () {
-        expect(schemaContainsGeoData(schema)).to.equal(false);
+      describe('with differing nested fields fields', function () {
+        let schema: Schema;
+        before(async function () {
+          schema = await mongoDBSchemaAnalyzeSchema([
+            { required: { notAlwaysPresent: 'yes' } },
+            { required: { notAlwaysPresent: 123456 } },
+            { required: { sometimesHere: true } },
+          ]);
+        });
+
+        it('returns does not count the optionals', async function () {
+          const { variable_type_count } = await calculateSchemaMetadata(schema);
+          expect(variable_type_count).to.equal(0);
+        });
       });
     });
 
-    describe('with a basic document without geo data', function () {
-      let schema: Schema;
-      before(async function () {
-        schema = await mongoDBSchemaAnalyzeSchema([
-          {
-            fruits: {
-              pineapple: 'yes',
-              apples: ['golden', 'fiji'],
-            },
-          },
-        ]);
+    describe('optional_field_count', function () {
+      describe('with optional fields', function () {
+        let schema: Schema;
+        before(async function () {
+          schema = await mongoDBSchemaAnalyzeSchema([
+            { pineapple: 'yes', optional: 123 },
+            { pineapple: 'yes' },
+            { pineapple: 'yes', optional: 'maybe' },
+          ]);
+        });
+
+        it('counts fields missing from some documents', async function () {
+          const { optional_field_count } = await calculateSchemaMetadata(
+            schema
+          );
+          expect(optional_field_count).to.equal(1);
+        });
       });
 
-      it('does not detect geo data', function () {
-        expect(schemaContainsGeoData(schema)).to.equal(false);
+      describe('with no fields', function () {
+        let schema: Schema;
+        before(async function () {
+          schema = await mongoDBSchemaAnalyzeSchema([{}]);
+        });
+
+        it('returns zero', async function () {
+          const { optional_field_count } = await calculateSchemaMetadata(
+            schema
+          );
+          expect(optional_field_count).to.equal(0);
+        });
       });
-    });
 
-    describe('with more complex documents without geo data', function () {
-      let schema: Schema;
-      before(async function () {
-        schema = await mongoDBSchemaAnalyzeSchema(testDocs);
+      describe('with all required fields', function () {
+        let schema: Schema;
+        before(async function () {
+          schema = await mongoDBSchemaAnalyzeSchema([
+            { required: 1 },
+            { required: 2 },
+            { required: 3 },
+          ]);
+        });
+
+        it('returns zero', async function () {
+          const { optional_field_count } = await calculateSchemaMetadata(
+            schema
+          );
+          expect(optional_field_count).to.equal(0);
+        });
       });
 
-      it('does not detect geo data', function () {
-        expect(schemaContainsGeoData(schema)).to.equal(false);
+      describe('with differing nested fields fields', function () {
+        let schema: Schema;
+        before(async function () {
+          schema = await mongoDBSchemaAnalyzeSchema([
+            { required: { notAlwaysPresent: true } },
+            { required: { notAlwaysPresent: true } },
+            { required: { sometimesHere: true } },
+          ]);
+        });
+
+        it('returns does not count the optionals', async function () {
+          const { optional_field_count } = await calculateSchemaMetadata(
+            schema
+          );
+          expect(optional_field_count).to.equal(0);
+        });
       });
     });
 
-    describe('with a basic document with Point geo data', function () {
-      let schema: Schema;
-      before(async function () {
-        schema = await mongoDBSchemaAnalyzeSchema([
-          {
-            name: 'somewhere',
-            location: {
-              type: 'Point',
-              coordinates: [-73.856077, 40.848447],
+    describe('field_types', function () {
+      describe('with mixed bson types', function () {
+        let schema: Schema;
+        before(async function () {
+          schema = await mongoDBSchemaAnalyzeSchema([
+            { number: 42, value: true, string: 'test' },
+            {
+              number: 100,
+              value: 'ok',
+              anotherString: 'hello',
+              yetAnotherString: 'blueberry',
             },
-          },
-        ]);
+          ]);
+        });
+
+        it('correctly counts the bson types', async function () {
+          const { field_types } = await calculateSchemaMetadata(schema);
+          expect(field_types).to.deep.equal({
+            Number: 1,
+            Boolean: 1,
+            String: 4,
+          });
+        });
       });
 
-      it('detects geo data', function () {
-        expect(schemaContainsGeoData(schema)).to.equal(true);
+      describe('with no fields', function () {
+        let schema: Schema;
+        before(async function () {
+          schema = await mongoDBSchemaAnalyzeSchema([{}]);
+        });
+
+        it('returns an empty object', async function () {
+          const { field_types } = await calculateSchemaMetadata(schema);
+          expect(field_types).to.deep.equal({});
+        });
       });
-    });
 
-    describe('with Polygon geo data', function () {
-      let schema: Schema;
-      before(async function () {
-        schema = await mongoDBSchemaAnalyzeSchema([
-          {
-            type: 'geojson',
-            data: {
-              type: 'Feature',
-              geometry: {
-                type: 'Polygon',
-                coordinates: [
-                  [
-                    [-73.856077, 40.848447],
-                    [-72.856077, 41.848447],
-                    [-73.856077, 41.848447],
-                    [-72.856077, 40.848447],
-                  ],
-                ],
-              },
-            },
-          },
-        ]);
+      describe('with a type occurring multiple times', function () {
+        let schema: Schema;
+        before(async function () {
+          schema = await mongoDBSchemaAnalyzeSchema([
+            { pineapple: 1, secondPineapple: 2, singlePineapple: 3 },
+            { pineapple: 1, secondPineapple: 2 },
+            { pineapple: 2, secondPineapple: 2 },
+          ]);
+        });
+
+        it('correctly counts a single type', async function () {
+          const { field_types } = await calculateSchemaMetadata(schema);
+          expect(field_types).to.deep.equal({
+            Number: 3,
+          });
+        });
       });
 
-      it('detects geo data', function () {
-        expect(schemaContainsGeoData(schema)).to.equal(true);
+      describe('with nested arrays and objects', function () {
+        let schema: Schema;
+        before(async function () {
+          schema = await mongoDBSchemaAnalyzeSchema([
+            {
+              arrayField: [[[['a']]]],
+            },
+            {
+              arrayField: [[[['a', 123]]]],
+              objectField: {
+                innerObject: {
+                  pineapple: 'wahoo',
+                  anotherNumberInObject: 55,
+                },
+                numberInObject: 42,
+              },
+            },
+          ]);
+        });
+
+        it('correctly counts bson types', async function () {
+          const { field_types } = await calculateSchemaMetadata(schema);
+          expect(field_types).to.deep.equal({
+            Document: 2,
+            Array: 4,
+            String: 2,
+            Number: 3,
+          });
+        });
       });
     });
   });
diff --git a/packages/compass-schema/src/modules/schema-analysis.ts b/packages/compass-schema/src/modules/schema-analysis.ts
index aaa5193979a..5a9eae71218 100644
--- a/packages/compass-schema/src/modules/schema-analysis.ts
+++ b/packages/compass-schema/src/modules/schema-analysis.ts
@@ -12,16 +12,6 @@ import type {
 import type { DataService } from '../stores/store';
 import type { Logger } from '@mongodb-js/compass-logging';
 
-const MONGODB_GEO_TYPES = [
-  'Point',
-  'LineString',
-  'Polygon',
-  'MultiPoint',
-  'MultiLineString',
-  'MultiPolygon',
-  'GeometryCollection',
-];
-
 // hack for driver 3.6 not promoting error codes and
 // attributes from ejson when promoteValue is false.
 function promoteMongoErrorCode(err?: Error & { code?: unknown }) {
@@ -91,76 +81,141 @@ export const analyzeSchema = async (
   }
 };
 
-function _calculateSchemaFieldDepth(
-  fieldsOrTypes: SchemaField[] | SchemaType[]
-): number {
-  if (!fieldsOrTypes || fieldsOrTypes.length === 0) {
-    return 0;
-  }
+function isSchemaType(
+  fieldOrType: SchemaField | SchemaType
+): fieldOrType is SchemaType {
+  return (fieldOrType as SchemaType).bsonType !== undefined;
+}
 
-  let deepestPath = 1;
-  for (const fieldOrType of fieldsOrTypes) {
-    if ((fieldOrType as DocumentSchemaType).bsonType === 'Document') {
-      const deepestFieldPath =
-        _calculateSchemaFieldDepth((fieldOrType as DocumentSchemaType).fields) +
-        1; /* Increment by one when we go a level deeper. */
-
-      deepestPath = Math.max(deepestFieldPath, deepestPath);
-    } else if (
-      (fieldOrType as ArraySchemaType).bsonType === 'Array' ||
-      (fieldOrType as SchemaField).types
-    ) {
-      // Increment by one when we go a level deeper.
-      const increment =
-        (fieldOrType as ArraySchemaType).bsonType === 'Array' ? 1 : 0;
-      const deepestFieldPath =
-        _calculateSchemaFieldDepth(
-          (fieldOrType as ArraySchemaType | SchemaField).types
-        ) + increment;
-
-      deepestPath = Math.max(deepestFieldPath, deepestPath);
-    }
-  }
+const MONGODB_GEO_TYPES = [
+  'Point',
+  'LineString',
+  'Polygon',
+  'MultiPoint',
+  'MultiLineString',
+  'MultiPolygon',
+  'GeometryCollection',
+];
 
-  return deepestPath;
-}
+// Every 1000 iterations, unblock the thread.
+const UNBLOCK_INTERVAL_COUNT = 1000;
+const unblockThread = async () =>
+  new Promise<void>((resolve) => setTimeout(resolve));
+
+export async function calculateSchemaMetadata(schema: Schema): Promise<{
+  /**
+   * Key/value pairs of bsonType and count.
+   */
+  field_types: {
+    [bsonType: string]: number;
+  };
+
+  /**
+   * The count of fields with multiple types in a given schema (not counting undefined).
+   * This is only calculated for the top level fields, not nested fields and arrays.
+   */
+  variable_type_count: number;
+
+  /**
+   * The count of fields that don't appear on all documents.
+   * This is only calculated for the top level fields, not nested fields and arrays.
+   */
+  optional_field_count: number;
+
+  /**
+   * The number of nested levels.
+   */
+  schema_depth: number;
+
+  /**
+   * Indicates whether the schema contains geospatial data.
+   */
+  geo_data: boolean;
+}> {
+  let hasGeoData = false;
+  const fieldTypes: {
+    [bsonType: string]: number;
+  } = {};
+  let variableTypeCount = 0;
+  let optionalFieldCount = 0;
+  let unblockThreadCounter = 0;
+  let deepestPath = 0;
+
+  async function traverseSchemaTree(
+    fieldsOrTypes: SchemaField[] | SchemaType[],
+    depth: number
+  ): Promise<void> {
+    unblockThreadCounter++;
+    if (unblockThreadCounter === UNBLOCK_INTERVAL_COUNT) {
+      unblockThreadCounter = 0;
+      await unblockThread();
+    }
 
-export function calculateSchemaDepth(schema: Schema): number {
-  const schemaDepth = _calculateSchemaFieldDepth(schema.fields);
-  return schemaDepth;
-}
+    if (!fieldsOrTypes || fieldsOrTypes.length === 0) {
+      return;
+    }
 
-function _containsGeoData(
-  fieldsOrTypes: SchemaField[] | SchemaType[]
-): boolean {
-  if (!fieldsOrTypes) {
-    return false;
-  }
+    deepestPath = Math.max(depth, deepestPath);
 
-  for (const fieldOrType of fieldsOrTypes) {
-    if (
-      fieldOrType.path[fieldOrType.path.length - 1] === 'type' &&
-      (fieldOrType as PrimitiveSchemaType).values &&
-      MONGODB_GEO_TYPES.find((geoType) =>
-        (fieldOrType as PrimitiveSchemaType).values?.find(
-          (value) => value === geoType
+    for (const fieldOrType of fieldsOrTypes) {
+      if (
+        fieldOrType.path[fieldOrType.path.length - 1] === 'type' &&
+        (fieldOrType as PrimitiveSchemaType).values &&
+        MONGODB_GEO_TYPES.find((geoType) =>
+          (fieldOrType as PrimitiveSchemaType).values?.find(
+            (value) => value === geoType
+          )
         )
-      )
-    ) {
-      return true;
-    }
+      ) {
+        hasGeoData = true;
+      }
 
-    const hasGeoData = _containsGeoData(
-      (fieldOrType as ArraySchemaType | SchemaField).types ??
-        (fieldOrType as DocumentSchemaType).fields
-    );
-    if (hasGeoData) {
-      return true;
+      if (isSchemaType(fieldOrType)) {
+        if (fieldOrType.bsonType !== 'Undefined') {
+          fieldTypes[fieldOrType.bsonType] =
+            (fieldTypes[fieldOrType.bsonType] ?? 0) + 1;
+        }
+      } else if (depth === 1 /* is root level */) {
+        // Count variable types (more than one unique type excluding undefined).
+        if (
+          fieldOrType.types &&
+          (fieldOrType.types.length > 2 ||
+            fieldOrType.types?.filter((t) => t.name !== 'Undefined').length > 1)
+        ) {
+          variableTypeCount++;
+        }
+
+        if (fieldOrType.probability < 1) {
+          optionalFieldCount++;
+        }
+      }
+
+      if ((fieldOrType as DocumentSchemaType).bsonType === 'Document') {
+        await traverseSchemaTree(
+          (fieldOrType as DocumentSchemaType).fields,
+          depth + 1 // Increment by one when we go a level deeper.
+        );
+      } else if (
+        (fieldOrType as ArraySchemaType).bsonType === 'Array' ||
+        (fieldOrType as SchemaField).types
+      ) {
+        const increment =
+          (fieldOrType as ArraySchemaType).bsonType === 'Array' ? 1 : 0;
+        await traverseSchemaTree(
+          (fieldOrType as ArraySchemaType | SchemaField).types,
+          depth + increment // Increment by one when we go a level deeper.
+        );
+      }
     }
   }
-  return false;
-}
 
-export function schemaContainsGeoData(schema: Schema): boolean {
-  return _containsGeoData(schema.fields);
+  await traverseSchemaTree(schema.fields, 1);
+
+  return {
+    field_types: fieldTypes,
+    geo_data: hasGeoData,
+    optional_field_count: optionalFieldCount,
+    schema_depth: deepestPath,
+    variable_type_count: variableTypeCount,
+  };
 }
diff --git a/packages/compass-schema/src/stores/schema-analysis-reducer.ts b/packages/compass-schema/src/stores/schema-analysis-reducer.ts
index 14f8ec13047..a5bf0621256 100644
--- a/packages/compass-schema/src/stores/schema-analysis-reducer.ts
+++ b/packages/compass-schema/src/stores/schema-analysis-reducer.ts
@@ -2,6 +2,7 @@ import type { Schema } from 'mongodb-schema';
 import { isInternalFieldPath } from 'hadron-document';
 import type { Action, Reducer } from 'redux';
 import type { AggregateOptions } from 'mongodb';
+import type { QueryBarService } from '@mongodb-js/compass-query-bar';
 import { type AnalysisState } from '../constants/analysis-states';
 import {
   ANALYSIS_STATE_ANALYZING,
@@ -13,8 +14,7 @@ import {
 import { addLayer, generateGeoQuery } from '../modules/geo';
 import {
   analyzeSchema,
-  calculateSchemaDepth,
-  schemaContainsGeoData,
+  calculateSchemaMetadata,
 } from '../modules/schema-analysis';
 import { capMaxTimeMSAtPreferenceLimit } from 'compass-preferences-model/provider';
 import type { Circle, Layer, LayerGroup, Polygon } from 'leaflet';
@@ -29,6 +29,7 @@ const ERROR_CODE_MAX_TIME_MS_EXPIRED = 50;
 
 export type SchemaAnalysisState = {
   analysisState: AnalysisState;
+  analysisStartTime?: number;
   errorMessage: string;
   schema: Schema | null;
   resultId: string;
@@ -42,6 +43,7 @@ export const enum SchemaAnalysisActions {
 
 export type AnalysisStartedAction = {
   type: SchemaAnalysisActions.analysisStarted;
+  analysisStartTime: number;
 };
 
 export type AnalysisFinishedAction = {
@@ -66,6 +68,7 @@ export const schemaAnalysisReducer: Reducer<SchemaAnalysisState, Action> = (
   ) {
     return {
       ...state,
+      analysisStartTime: action.analysisStartTime,
       analysisState: ANALYSIS_STATE_ANALYZING,
       errorMessage: '',
       schema: null,
@@ -165,12 +168,75 @@ export const geoLayersDeleted = (
 };
 
 export const stopAnalysis = (): SchemaThunkAction<void> => {
+  return (
+    dispatch,
+    getState,
+    { analysisAbortControllerRef, connectionInfoRef, queryBar, track }
+  ) => {
+    if (!analysisAbortControllerRef.current) return;
+    const analysisTime =
+      Date.now() - (getState().schemaAnalysis.analysisStartTime ?? 0);
+
+    const query = queryBar.getLastAppliedQuery('schema');
+    track(
+      'Schema Analysis Cancelled',
+      {
+        analysis_time_ms: analysisTime,
+        with_filter: Object.entries(query.filter ?? {}).length > 0,
+      },
+      connectionInfoRef.current
+    );
+
+    analysisAbortControllerRef.current?.abort('Analysis cancelled');
+  };
+};
+
+export const cleanupAnalysis = (): SchemaThunkAction<void> => {
   return (dispatch, getState, { analysisAbortControllerRef }) => {
     if (!analysisAbortControllerRef.current) return;
     analysisAbortControllerRef.current?.abort();
   };
 };
 
+const getSchemaAnalyzedEventPayload = ({
+  schema,
+  query,
+  analysisTime,
+}: {
+  schema: Schema | null;
+  query: ReturnType<QueryBarService['getLastAppliedQuery']>;
+  analysisTime: number;
+}) => {
+  return async () => {
+    const {
+      field_types,
+      geo_data,
+      optional_field_count,
+      schema_depth,
+      variable_type_count,
+    } = schema
+      ? await calculateSchemaMetadata(schema)
+      : {
+          field_types: {},
+          geo_data: false,
+          optional_field_count: 0,
+          schema_depth: 0,
+          variable_type_count: 0,
+        };
+
+    return {
+      with_filter: Object.entries(query.filter ?? {}).length > 0,
+      schema_width: schema?.fields?.length ?? 0,
+      field_types,
+      variable_type_count,
+      optional_field_count,
+      schema_depth,
+      geo_data,
+      analysis_time_ms: analysisTime,
+    };
+  };
+};
+
 export const startAnalysis = (): SchemaThunkAction<
   Promise<void>,
   AnalysisStartedAction | AnalysisFinishedAction | AnalysisFailedAction
@@ -219,12 +285,15 @@ export const startAnalysis = (): SchemaThunkAction<
     analysisAbortControllerRef.current = new AbortController();
     const abortSignal = analysisAbortControllerRef.current.signal;
 
+    const analysisStartTime = Date.now();
     try {
       debug('analysis started');
 
-      dispatch({ type: SchemaAnalysisActions.analysisStarted });
+      dispatch({
+        type: SchemaAnalysisActions.analysisStarted,
+        analysisStartTime,
+      });
 
-      const analysisStartTime = Date.now();
       const schemaAccessor = await analyzeSchema(
         dataService,
         abortSignal,
@@ -233,6 +302,10 @@ export const startAnalysis = (): SchemaThunkAction<
         driverOptions,
         logger
       );
+      if (abortSignal?.aborted) {
+        throw new Error(abortSignal?.reason || new Error('Operation aborted'));
+      }
+
       schemaAccessorRef.current = schemaAccessor;
       let schema: Schema | null = null;
       if (schemaAccessor) {
@@ -252,15 +325,15 @@ export const startAnalysis = (): SchemaThunkAction<
         schema,
       });
 
-      // track schema analyzed
-      const trackEvent = () => ({
-        with_filter: Object.entries(query.filter ?? {}).length > 0,
-        schema_width: schema?.fields?.length ?? 0,
-        schema_depth: schema ? calculateSchemaDepth(schema) : 0,
-        geo_data: schema ? schemaContainsGeoData(schema) : false,
-        analysis_time_ms: analysisTime,
-      });
-      track('Schema Analyzed', trackEvent, connectionInfoRef.current);
+      track(
+        'Schema Analyzed',
+        getSchemaAnalyzedEventPayload({
+          schema,
+          query,
+          analysisTime,
+        }),
+        connectionInfoRef.current
+      );
 
       geoLayersRef.current = {};
     } catch (err: any) {
diff --git a/packages/compass-schema/src/stores/schema-export-reducer.ts b/packages/compass-schema/src/stores/schema-export-reducer.ts
index 80d0f8ec64f..1c309eec250 100644
--- a/packages/compass-schema/src/stores/schema-export-reducer.ts
+++ b/packages/compass-schema/src/stores/schema-export-reducer.ts
@@ -7,14 +7,11 @@ import type {
   ExpandedJSONSchema,
   SchemaAccessor,
 } from 'mongodb-schema';
+import { openToast } from '@mongodb-js/compass-components';
 
 import type { SchemaThunkAction } from './store';
 import { isAction } from '../utils';
-import {
-  calculateSchemaDepth,
-  schemaContainsGeoData,
-} from '../modules/schema-analysis';
-import { openToast } from '@mongodb-js/compass-components';
+import { calculateSchemaMetadata } from '../modules/schema-analysis';
 
 export type SchemaFormat =
   | 'standardJSON'
@@ -153,6 +150,57 @@ async function getSchemaByFormat({
   return JSON.stringify(schema, null, 2);
 }
 
+const _trackSchemaExported = ({
+  schema,
+  source,
+  format,
+}: {
+  schema: InternalSchema | null;
+  source: 'app_menu' | 'schema_tab';
+  format: SchemaFormat;
+}): SchemaThunkAction<void> => {
+  return (dispatch, getState, { track, connectionInfoRef }) => {
+    // Use a function here to a) ensure that the calculations here
+    // are only made when telemetry is enabled and b) that errors from
+    // those calculations are caught and logged rather than displayed to
+    // users as errors from the core schema sharing logic.
+    const trackEvent = async () => {
+      const { geo_data, schema_depth } = schema
+        ? await calculateSchemaMetadata(schema)
+        : {
+            geo_data: false,
+            schema_depth: 0,
+          };
+
+      return {
+        has_schema: schema !== null,
+        format,
+        source,
+        schema_width: schema?.fields?.length ?? 0,
+        schema_depth,
+        geo_data,
+      };
+    };
+    track('Schema Exported', trackEvent, connectionInfoRef.current);
+  };
+};
+
+export const trackSchemaExported = (): SchemaThunkAction<void> => {
+  return (dispatch, getState) => {
+    const {
+      schemaAnalysis: { schema },
+      schemaExport: { exportFormat },
+    } = getState();
+    dispatch(
+      _trackSchemaExported({
+        schema,
+        format: exportFormat,
+        source: 'schema_tab',
+      })
+    );
+  };
+};
+
 export const changeExportSchemaFormat = (
   exportFormat: SchemaFormat
 ): SchemaThunkAction<
@@ -177,17 +225,17 @@ export const changeExportSchemaFormat = (
       exportFormat,
     });
 
+    log.info(
+      mongoLogId(1_001_000_342),
+      'Schema export formatting',
+      'Formatting schema',
+      {
+        format: exportFormat,
+      }
+    );
+
     let exportedSchema: string;
     try {
-      log.info(
-        mongoLogId(1_001_000_342),
-        'Schema export formatting',
-        'Formatting schema',
-        {
-          format: exportFormat,
-        }
-      );
-
       const schemaAccessor = schemaAccessorRef.current;
       if (!schemaAccessor) {
         throw new Error('No schema analysis available');
@@ -376,7 +424,7 @@ export const openLegacyBanner = (): SchemaThunkAction<void> => {
         });
       }
       if (savedChoice === 'legacy') {
-        dispatch(confirmedLegacySchemaShare());
+        dispatch(confirmedExportLegacySchemaToClipboard());
         return;
       }
       if (savedChoice === 'export') {
@@ -406,56 +454,42 @@ export const switchToSchemaExport = (): SchemaThunkAction<void> => {
   };
 };
 
-export const confirmedLegacySchemaShare = (): SchemaThunkAction<void> => {
-  return (dispatch, getState, { namespace }) => {
-    const {
-      schemaAnalysis: { schema },
-    } = getState();
-    const hasSchema = schema !== null;
-    if (hasSchema) {
-      void navigator.clipboard.writeText(JSON.stringify(schema, null, '  '));
-    }
-    dispatch(_trackSchemaShared(hasSchema));
-    dispatch({ type: SchemaExportActions.closeLegacyBanner });
-    openToast(
-      'share-schema',
-      hasSchema
-        ? {
-            variant: 'success',
-            title: 'Schema Copied',
-            description: `The schema definition of ${namespace} has been copied to your clipboard in JSON format.`,
-            timeout: 5_000,
-          }
-        : {
-            variant: 'warning',
-            title: 'Analyze Schema First',
-            description:
-              'Please analyze the schema in the schema tab before sharing the schema.',
-          }
-    );
-  };
-};
-
-export const _trackSchemaShared = (
-  hasSchema: boolean
-): SchemaThunkAction<void> => {
-  return (dispatch, getState, { track, connectionInfoRef }) => {
-    const {
-      schemaAnalysis: { schema },
-    } = getState();
-    // Use a function here to a) ensure that the calculations here
-    // are only made when telemetry is enabled and b) that errors from
-    // those calculations are caught and logged rather than displayed to
-    // users as errors from the core schema sharing logic.
-    const trackEvent = () => ({
-      has_schema: hasSchema,
-      schema_width: schema?.fields?.length ?? 0,
-      schema_depth: schema ? calculateSchemaDepth(schema) : 0,
-      geo_data: schema ? schemaContainsGeoData(schema) : false,
-    });
-    track('Schema Exported', trackEvent, connectionInfoRef.current);
+export const confirmedExportLegacySchemaToClipboard =
+  (): SchemaThunkAction<void> => {
+    return (dispatch, getState, { namespace }) => {
+      const {
+        schemaAnalysis: { schema },
+      } = getState();
+      const hasSchema = schema !== null;
+      if (hasSchema) {
+        void navigator.clipboard.writeText(JSON.stringify(schema, null, '  '));
+      }
+      dispatch(
+        _trackSchemaExported({
+          schema,
+          source: 'app_menu',
+          format: 'legacyJSON',
+        })
+      );
+      dispatch({ type: SchemaExportActions.closeLegacyBanner });
+      openToast(
+        'share-schema',
+        hasSchema
+          ? {
+              variant: 'success',
+              title: 'Schema Copied',
+              description: `The schema definition of ${namespace} has been copied to your clipboard in JSON format.`,
+              timeout: 5_000,
+            }
+          : {
+              variant: 'warning',
+              title: 'Analyze Schema First',
+              description:
+                'Please analyze the schema in the schema tab before sharing the schema.',
+            }
+      );
+    };
   };
-};
 
 export const stopShowingLegacyBanner = (
   choice: 'legacy' | 'export'
diff --git a/packages/compass-schema/src/stores/store.spec.ts b/packages/compass-schema/src/stores/store.spec.ts
index 470302af466..22e29d2621c 100644
--- a/packages/compass-schema/src/stores/store.spec.ts
+++ b/packages/compass-schema/src/stores/store.spec.ts
@@ -112,10 +112,17 @@ describe('Schema Store', function () {
       sampleStub.resolves([{ name: 'Hans' }, { name: 'Greta' }]);
       await store.dispatch(startAnalysis());
       expect(sampleStub).to.have.been.called;
-      const { analysisState, errorMessage, schema, resultId } =
-        store.getState().schemaAnalysis;
+      const {
+        analysisState,
+        errorMessage,
+        schema,
+        resultId,
+        analysisStartTime,
+      } = store.getState().schemaAnalysis;
       expect(analysisState).to.equal('complete');
       expect(!!errorMessage).to.be.false;
+      expect(analysisStartTime).to.not.be.undefined;
+      expect(analysisStartTime).to.be.greaterThan(1000);
       expect(schema).not.to.be.null;
       expect(resultId).not.to.equal(oldResultId);
     });
@@ -129,7 +136,7 @@ describe('Schema Store', function () {
       store.dispatch(stopAnalysis());
       isCancelErrorStub.returns(true);
       await analysisPromise;
-      expect(store.getState().schemaAnalysis.analysisState).to.equal('initial');
+      expect(store.getState().schemaAnalysis.analysisState).to.equal('error');
     });
 
     describe('schema export', function () {
diff --git a/packages/compass-schema/src/stores/store.ts b/packages/compass-schema/src/stores/store.ts
index 4f6c386d9c9..076ddab4d2c 100644
--- a/packages/compass-schema/src/stores/store.ts
+++ b/packages/compass-schema/src/stores/store.ts
@@ -18,10 +18,13 @@ import type { FieldStoreService } from '@mongodb-js/compass-field-store';
 import type { QueryBarService } from '@mongodb-js/compass-query-bar';
 import type { TrackFunction } from '@mongodb-js/compass-telemetry';
 import type { SchemaAccessor } from 'mongodb-schema';
-import { schemaAnalysisReducer, stopAnalysis } from './schema-analysis-reducer';
+import {
+  schemaAnalysisReducer,
+  cleanupAnalysis,
+} from './schema-analysis-reducer';
 import {
   cancelExportSchema,
-  confirmedLegacySchemaShare,
+  confirmedExportLegacySchemaToClipboard,
   openLegacyBanner,
   schemaExportReducer,
 } from './schema-export-reducer';
@@ -75,20 +78,20 @@ export function activateSchemaPlugin(
   { on, cleanup, addCleanup }: ActivateHelpers
 ) {
   const store = configureStore(services, namespace);
+
   /**
    * When `Share Schema as JSON` clicked in menu show a dialog message.
    */
-
   on(services.localAppRegistry, 'menu-share-schema-json', () => {
     const { enableExportSchema } = services.preferences.getPreferences();
     if (enableExportSchema) {
       store.dispatch(openLegacyBanner());
       return;
     }
-    store.dispatch(confirmedLegacySchemaShare());
+    store.dispatch(confirmedExportLegacySchemaToClipboard());
   });
 
-  addCleanup(() => store.dispatch(stopAnalysis()));
+  addCleanup(() => store.dispatch(cleanupAnalysis()));
   addCleanup(() => store.dispatch(cancelExportSchema()));
 
   return {
diff --git a/packages/compass-telemetry/src/telemetry-events.ts b/packages/compass-telemetry/src/telemetry-events.ts
index 22df5855633..4fde6b051f9 100644
--- a/packages/compass-telemetry/src/telemetry-events.ts
+++ b/packages/compass-telemetry/src/telemetry-events.ts
@@ -1934,6 +1934,25 @@ type SchemaAnalyzedEvent = ConnectionScopedEvent<{
      */
     schema_width: number;
 
+    /**
+     * Key/value pairs of bsonType and count.
+     */
+    field_types: {
+      [bsonType: string]: number;
+    };
+
+    /**
+     * The count of fields with multiple types in a given schema (not counting undefined).
+     * This is only calculated for the top level fields, not nested fields and arrays.
+     */
+    variable_type_count: number;
+
+    /**
+     * The count of fields that don't appear on all documents.
+     * This is only calculated for the top level fields, not nested fields and arrays.
+     */
+    optional_field_count: number;
+
     /**
      * The number of nested levels.
      */
@@ -1951,6 +1970,26 @@ type SchemaAnalyzedEvent = ConnectionScopedEvent<{
   };
 }>;
 
+/**
+ * This event is fired when user analyzes the schema.
+ *
+ * @category Schema
+ */
+type SchemaAnalysisCancelledEvent = ConnectionScopedEvent<{
+  name: 'Schema Analysis Cancelled';
+  payload: {
+    /**
+     * Indicates whether a filter was applied during the schema analysis.
+     */
+    with_filter: boolean;
+
+    /**
+     * The time taken when analyzing the schema, before being cancelled, in milliseconds.
+     */
+    analysis_time_ms: number;
+  };
+}>;
+
 /**
  * This event is fired when user shares the schema.
  *
@@ -1964,6 +2003,10 @@ type SchemaExportedEvent = ConnectionScopedEvent<{
      */
     has_schema: boolean;
 
+    format: 'standardJSON' | 'mongoDBJSON' | 'extendedJSON' | 'legacyJSON';
+
+    source: 'app_menu' | 'schema_tab';
+
     /**
      * The number of fields at the top level.
      */
@@ -2683,6 +2726,7 @@ export type TelemetryEvent =
   | QueryHistoryRecentEvent
   | QueryHistoryRecentUsedEvent
   | QueryResultsRefreshedEvent
+  | SchemaAnalysisCancelledEvent
   | SchemaAnalyzedEvent
   | SchemaExportedEvent
   | SchemaValidationAddedEvent