Spec runner

Author: comandeo-mongo

lib/mongo.rb

@@ -33,6 +33,7 @@
 autoload :CGI, 'cgi'
 
 require 'bson'
+require 'opentelemetry-api'
 
 require 'mongo/id'
 require 'mongo/bson'

lib/mongo/tracing/open_telemetry/command_tracer.rb

@@ -65,6 +65,7 @@ def span_attributes(message, connection)
             'db.namespace' => database(message),
             'db.collection.name' => collection_name(message),
             'db.command.name' => command_name(message),
+            'db.query.summary' => command_span_name(message),
             'server.port' => connection.address.port,
             'server.address' => connection.address.host,
             'network.transport' => connection.transport.to_s,

lib/mongo/tracing/open_telemetry/operation_tracer.rb

@@ -58,7 +58,7 @@ def trace_operation(operation, operation_context)
         private
 
         def operation_name(operation)
-          operation.class.name.split('::').last
+          operation.class.name.split('::').last.downcase
         end
 
         def span_attributes(operation)

spec/runners/unified.rb

@@ -99,6 +99,7 @@ def define_unified_spec_tests(base_path, paths, expect_failure: false)
               test.run
               test.assert_outcome
               test.assert_events
+              test.assert_tracing_messages
               test.cleanup
             end
           end

spec/runners/unified/assertions.rb

@@ -140,9 +140,14 @@ def assert_documents_match(actual, expected)
       end
     end
 
-    def assert_document_matches(actual, expected, msg)
-      unless actual == expected
-        raise Error::ResultMismatch, "#{msg} does not match"
+    def assert_document_matches(actual, expected, msg, as_root: false)
+      if !as_root && actual.keys.to_set != expected.keys.to_set
+        raise Error::ResultMismatch, "#{msg} keys do not match: expected #{expected.keys}, actual #{actual.keys}"
+      end
+      expected.each do |key, expected_value|
+        raise Error::ResultMismatch, "#{msg} has no key #{key}" unless actual.key?(key)
+        actual_value = actual[key]
+        assert_value_matches(actual_value, expected_value, "#{msg} key #{key}")
       end
     end
 
@@ -383,6 +388,14 @@ def assert_value_matches(actual, expected, msg)
           if actual.nil? || actual >= expected_v
             raise Error::ResultMismatch, "Actual value #{actual} should be less than #{expected_v}"
           end
+        when '$$matchAsDocument'
+          actual_v = BSON::ExtJSON.parse(actual)
+          match_as_root = false
+          if expected_v.keys.first == '$$matchAsRoot'
+            expected_v = expected_v.values.first
+            match_as_root = true
+          end
+          assert_document_matches(actual_v, expected_v, msg, as_root: match_as_root)
         else
           raise NotImplementedError, "Unknown operator #{operator}"
         end
@@ -392,5 +405,44 @@ def assert_value_matches(actual, expected, msg)
         end
       end
     end
+
+    def assert_tracing_messages
+      return unless @expected_tracing_messages
+      @expected_tracing_messages.each do |spec|
+        spec = UsingHash[spec]
+        client_id = spec.use!('client')
+        client = entities.get(:client, client_id)
+        tracer = @tracers.fetch(client)
+        expected_spans = spec.use!('spans')
+        ignore_extra_spans = if ignore = spec.use('ignoreExtraSpans')
+          # Ruby treats 0 as truthy, whereas the spec tests use it as falsy.
+          ignore == 0 ? false : ignore
+        else
+          false
+        end
+        actual_spans = tracer.span_hierarchy
+        if (!ignore_extra_spans && actual_spans.length != expected_spans.length) ||
+            (ignore_extra_spans && actual_spans.length < expected_spans.length)
+          raise Error::ResultMismatch, "Span count mismatch: expected #{expected_spans.length}, actual #{actual_spans.length}\nExpected: #{expected_spans}\nActual: #{actual_spans}"
+        end
+        expected_spans.each_with_index do |expected, i|
+          assert_span_matches(actual_spans[i], expected)
+        end
+      end
+    end
+
+    def assert_span_matches(actual, expected)
+      assert_eq(actual.name, expected.use!('name'), 'Span name does not match')
+      expected_attributes = UsingHash[expected.use!('tags')]
+      expected_attributes.each do |key, value|
+        actual_value = actual.attributes[key]
+        assert_value_matches(actual_value, value, "Span attribute #{key}")
+      end
+
+      expected_nested_spans = expected.use('nested') || []
+      expected_nested_spans.each_with_index do |nested_expected, i|
+        assert_span_matches(actual.nested[i], nested_expected)
+      end
+    end
   end
 end

spec/runners/unified/test.rb

@@ -37,6 +37,7 @@ def initialize(spec, **opts)
       @description = @test_spec.use('description')
       @outcome = @test_spec.use('outcome')
       @expected_events = @test_spec.use('expectEvents')
+      @expected_tracing_messages = @test_spec.use('expectTracingMessages')
       @expected_spans = @test_spec.use('expectSpans')
       @skip_reason = @test_spec.use('skipReason')
       if req = @test_spec.use('runOnRequirements')
@@ -55,6 +56,7 @@ def initialize(spec, **opts)
       end
       @test_spec.freeze
       @subscribers = {}
+      @tracers = {}
       @observe_sensitive = {}
       @options = opts
     end
@@ -196,17 +198,24 @@ def generate_entities(es)
             end
           end
 
-          observe_spans = spec.use('observeSpans')
-          if observe_spans
+          observe_tracing_messages = spec.use('observeTracingMessages')
+          tracer = ::Tracing::Tracer.new
+          if observe_tracing_messages
             opts[:tracing] = {
               enabled: true,
-              # tracer: tracer,
+              tracer: tracer,
             }
+            if observe_tracing_messages['enableCommandPayload']
+              # Set the maximum length of the query text to reasonably high
+              # value so that we can capture the full query text
+              opts[:tracing][:query_text_max_length] = 4096
+            end
           end
 
           create_client(**opts).tap do |client|
             @observe_sensitive[id] = spec.use('observeSensitiveCommands')
             @subscribers[client] ||= subscriber
+            @tracers[client] ||= tracer
           end
         when 'database'
           client = entities.get(:client, spec.use!('client'))
@@ -611,9 +620,5 @@ def bson_error
         BSON::String.const_get(:IllegalKey) :
         BSON::Error
     end
-
-    def tracer
-      @tracer ||= ::Tracing::Tracer.new
-    end
   end
 end

spec/spec_tests/data/crud_unified/find-comment.yml

@@ -6,7 +6,6 @@ createEntities:
   - client:
       id: &client0 client0
       observeEvents: [ commandStartedEvent ]
-      observeSpans: true
   - database:
       id: &database0 database0
       client: *client0
@@ -48,15 +47,6 @@ tests:
                 find: *collection0Name
                 filter: *filter
                 comment: "comment"
-    expectSpans:
-      - client: *client0
-        spans:
-          - name: "find"
-            attributes:
-              mongodb.collection: *collection0Name
-              mongodb.database: *database0Name
-              mongodb.filter: *filter
-              mongodb.comment: "comment"
 
   - description: "find with document comment"
     runOnRequirements:

spec/spec_tests/data/open_telemetry/README.md

@@ -0,0 +1,34 @@
+# OpenTelemetry Tests
+
+______________________________________________________________________
+
+## Testing
+
+### Automated Tests
+
+The YAML and JSON files in this directory are platform-independent tests meant to exercise a driver's implementation of
+the OpenTelemetry specification. These tests utilize the
+[Unified Test Format](../../unified-test-format/unified-test-format.md).
+
+For each test, create a MongoClient, configure it to enable tracing.
+
+```yaml
+createEntities:
+  - client:
+      id: client0
+      observeTracingMessages:
+        enableCommandPayload: true
+```
+
+These tests require the ability to collect tracing [spans](../open-telemetry.md#span) data in a structured form as
+described in the
+[Unified Test Format specification.expectTracingMessages](../../unified-test-format/unified-test-format.md#expectTracingMessages).
+For example the Java driver uses [Micrometer](https://jira.mongodb.org/browse/JAVA-5732) to collect tracing spans.
+
+```yaml
+expectTracingMessages:
+  client: client0
+  ignoreExtraSpans: false
+  spans:
+   ...
+```

spec/spec_tests/data/open_telemetry/cursor/cursor.yml

@@ -0,0 +1,131 @@
+description: cursor retrieval
+schemaVersion: '1.26'
+createEntities:
+  - client:
+      id: &client0 client0
+      useMultipleMongoses: false
+      observeTracingMessages:
+        enableCommandPayload: true
+  - database:
+      id: &database0 database0
+      client: *client0
+      databaseName: cursor
+  - collection:
+      id: &collection0 collection0
+      database: *database0
+      collectionName: test
+initialData:
+  - collectionName: test
+    databaseName: cursor
+    documents:
+      - { _id: 1 }
+      - { _id: 2 }
+      - { _id: 3 }
+      - { _id: 4 }
+      - { _id: 5 }
+      - { _id: 6 }
+tests:
+  - description: find with a cursor
+    operations:
+      - name: find
+        object: *collection0
+        arguments:
+          filter: { _id: { $gt: 1 } }
+          batchSize: 2
+        expectResult:
+          - { _id: 2 }
+          - { _id: 3 }
+          - { _id: 4 }
+          - { _id: 5 }
+          - { _id: 6 }
+    expectTracingMessages:
+      client: *client0
+      ignoreExtraSpans: false
+      spans:
+        - name: find cursor.test
+          tags:
+            db.system: mongodb
+            db.namespace: cursor
+            db.collection.name: test
+            db.operation.name: find
+            db.operation.summary: find cursor.test
+          nested:
+            - name: command find
+              tags:
+                db.system: mongodb
+                db.namespace: cursor
+                db.collection.name: cursor.$cmd
+                db.command.name: find
+                network.transport: tcp
+                db.mongodb.cursor_id: { $$exists: false }
+                db.response.status_code: { $$exists: false }
+                exception.message: { $$exists: false }
+                exception.type: { $$exists: false }
+                exception.stacktrace: { $$exists: false }
+                server.address: { $$type: string }
+                server.port: { $$type: ['int', 'long'] }
+                server.type: { $$type: string }
+                db.query.summary: find
+                db.query.text:
+                  $$matchAsDocument:
+                    $$matchAsRoot:
+                      find: test
+                      filter: { _id: { $gt: 1 } }
+                      batchSize: 2
+                db.mongodb.server_connection_id:
+                  $$type: [ 'int', 'long' ]
+                db.mongodb.driver_connection_id:
+                  $$type: [ 'int', 'long' ]
+
+            - name: command getMore
+              tags:
+                db.system: mongodb
+                db.namespace: cursor
+                db.collection.name: cursor.$cmd
+                db.command.name: getMore
+                network.transport: tcp
+                db.mongodb.cursor_id: { $$type: [ 'int', 'long' ] }
+                db.response.status_code: { $$exists: false }
+                exception.message: { $$exists: false }
+                exception.type: { $$exists: false }
+                exception.stacktrace: { $$exists: false }
+                server.address: { $$type: string }
+                server.port: { $$type: ['int', 'long'] }
+                server.type: { $$type: string }
+                db.query.summary: getMore
+                db.query.text:
+                  $$matchAsDocument:
+                    $$matchAsRoot:
+                      getMore: { $$type: long }
+                      collection: test
+                      batchSize: 2
+                db.mongodb.server_connection_id:
+                  $$type: [ 'int', 'long' ]
+                db.mongodb.driver_connection_id:
+                  $$type: [ 'int', 'long' ]
+            - name: command getMore
+              tags:
+                db.system: mongodb
+                db.namespace: cursor
+                db.collection.name: cursor.$cmd
+                db.command.name: getMore
+                network.transport: tcp
+                db.mongodb.cursor_id: { $$type: [ 'int', 'long' ] }
+                db.response.status_code: { $$exists: false }
+                exception.message: { $$exists: false }
+                exception.type: { $$exists: false }
+                exception.stacktrace: { $$exists: false }
+                server.address: { $$type: string }
+                server.port: { $$type: ['int', 'long'] }
+                server.type: { $$type: string }
+                db.query.summary: getMore
+                db.query.text:
+                  $$matchAsDocument:
+                    $$matchAsRoot:
+                      getMore: { $$type: long }
+                      collection: test
+                      batchSize: 2
+                db.mongodb.server_connection_id:
+                  $$type: [ 'int', 'long' ]
+                db.mongodb.driver_connection_id:
+                  $$type: [ 'int', 'long' ]