GraphQL Operation Metrics and Attrs (#276)

* Working on graphql operation testing

* Working on graphql paths

Co-authored-by: Uma Annamalai <[email protected]>

* Ignore duplicate exceptions

* Finalize split of resolver and operation traces

* Clean up failing tests

* Clean up attribute addition code

* Fix bug in deepest path naming

* Fix graphql 2 tests

* Fix python2 copy bug

Co-authored-by: Uma Annamalai <[email protected]>

Author: TimPansino

newrelic/api/graphql_trace.py

@@ -13,32 +13,38 @@
 # limitations under the License.
 
 import functools
-import logging
 
 from newrelic.common.async_wrapper import async_wrapper
 from newrelic.api.time_trace import TimeTrace, current_trace
 from newrelic.common.object_wrapper import FunctionWrapper, wrap_object
-from newrelic.core.graphql_node import GraphQLNode
-from newrelic.core.stack_trace import current_stack
+from newrelic.core.graphql_node import GraphQLOperationNode, GraphQLResolverNode
 
-_logger = logging.getLogger(__name__)
-
-
-class GraphQLTrace(TimeTrace):
+class GraphQLOperationTrace(TimeTrace):
     def __init__(self, **kwargs):
         parent = None
         if kwargs:
             if len(kwargs) > 1:
                 raise TypeError("Invalid keyword arguments:", kwargs)
             parent = kwargs['parent']
-        super(GraphQLTrace, self).__init__(parent)
+        super(GraphQLOperationTrace, self).__init__(parent)
+
+        self.operation_name = None
+        self.operation_type = None
+        self.deepest_path = None
 
     def __repr__(self):
         return '<%s %s>' % (self.__class__.__name__, dict())
 
+    def finalize_data(self, *args, **kwargs):
+        self._add_agent_attribute("graphql.operation.type", self.operation_type)
+        self._add_agent_attribute("graphql.operation.name", self.operation_name)
+        self._add_agent_attribute("graphql.operation.deepestPath", self.deepest_path)
+
+        return super(GraphQLOperationTrace, self).finalize_data(*args, **kwargs)
+
 
     def create_node(self):
-        return GraphQLNode(
+        return GraphQLOperationNode(
             children=self.children,
             start_time=self.start_time,
             end_time=self.end_time,
@@ -47,23 +53,54 @@ def create_node(self):
             guid=self.guid,
             agent_attributes=self.agent_attributes,
             user_attributes=self.user_attributes,
+            operation_name=self.operation_name,
+            operation_type=self.operation_type,
+            deepest_path=self.deepest_path,
         )
 
 
-class GraphQLResolverTrace(TimeTrace):
-    def __init__(self, field_name=None, **kwargs):
-        parent = None
-        if kwargs:
-            if len(kwargs) > 1:
-                raise TypeError("Invalid keyword arguments:", kwargs)
-            parent = kwargs['parent']
-        super(GraphQLResolverTrace, self).__init__(parent)
+def GraphQLOperationTraceWrapper(wrapped):
+    def _nr_graphql_trace_wrapper_(wrapped, instance, args, kwargs):
+        wrapper = async_wrapper(wrapped)
+        if not wrapper:
+            parent = current_trace()
+            if not parent:
+                return wrapped(*args, **kwargs)
+        else:
+            parent = None
+
+        trace = GraphQLOperationTrace(parent=parent)
+
+        if wrapper:
+            return wrapper(wrapped, trace)(*args, **kwargs)
+
+        with trace:
+            return wrapped(*args, **kwargs)
+
+    return FunctionWrapper(wrapped, _nr_graphql_trace_wrapper_)
+
+
+def graphql_operation_trace():
+    return functools.partial(GraphQLOperationTraceWrapper)
+
+def wrap_graphql_operation_trace(module, object_path):
+    wrap_object(module, object_path, GraphQLOperationTraceWrapper)
+
 
+class GraphQLResolverTrace(GraphQLOperationTrace):
+    def __init__(self, field_name=None, **kwargs):
+        super(GraphQLResolverTrace, self).__init__(**kwargs)
         self.field_name = field_name
 
 
+    def finalize_data(self, *args, **kwargs):
+        self._add_agent_attribute("graphql.field.name", self.field_name)
+
+        return super(GraphQLResolverTrace, self).finalize_data(*args, **kwargs)
+
+
     def create_node(self):
-        return GraphQLNode(
+        return GraphQLResolverNode(
             field_name=self.field_name,
             children=self.children,
             start_time=self.start_time,
@@ -76,7 +113,7 @@ def create_node(self):
         )
 
 
-def GraphQLTraceWrapper(wrapped):
+def GraphQLResolverTraceWrapper(wrapped):
     def _nr_graphql_trace_wrapper_(wrapped, instance, args, kwargs):
         wrapper = async_wrapper(wrapped)
         if not wrapper:
@@ -86,7 +123,7 @@ def _nr_graphql_trace_wrapper_(wrapped, instance, args, kwargs):
         else:
             parent = None
 
-        trace = GraphQLTrace(parent=parent)
+        trace = GraphQLResolverTrace(parent=parent)
 
         if wrapper:
             return wrapper(wrapped, trace)(*args, **kwargs)
@@ -97,8 +134,8 @@ def _nr_graphql_trace_wrapper_(wrapped, instance, args, kwargs):
     return FunctionWrapper(wrapped, _nr_graphql_trace_wrapper_)
 
 
-def graphql_trace():
-    return functools.partial(GraphQLTraceWrapper)
+def graphql_resolver_trace():
+    return functools.partial(GraphQLResolverTraceWrapper)
 
-def wrap_graphql_trace(module, object_path):
-    wrap_object(module, object_path, GraphQLTraceWrapper)
+def wrap_graphql_resolver_trace(module, object_path):
+    wrap_object(module, object_path, GraphQLResolverTraceWrapper)

newrelic/core/attribute.py

@@ -74,7 +74,11 @@
         'peer.address',
         'graphql.field.name',
         'graphql.field.parentType',
-        'graphql.field.path'
+        'graphql.field.path',
+        'graphql.operation.name',
+        'graphql.operation.type',
+        'graphql.operation.deepestPath',
+        'graphql.operation.query',
 ))
 
 MAX_NUM_USER_ATTRIBUTES = 128

newrelic/core/graphql_node.py

@@ -14,52 +14,117 @@
 
 from collections import namedtuple
 
-import newrelic.core.attribute as attribute
 import newrelic.core.trace_node
 
-from newrelic.common import system_info
 from newrelic.core.metric import TimeMetric
 
 from newrelic.core.node_mixin import GenericNodeMixin
 
 
-_GraphQLNode = namedtuple('_GraphQLNode',
-        ['field_name', 'children', 'start_time', 'end_time',
-        'duration', 'exclusive', 'guid', 'agent_attributes',
-        'user_attributes'])
+_GraphQLOperationNode = namedtuple('_GraphQLNode',
+    ['operation_type', 'operation_name', 'deepest_path', 
+    'children', 'start_time', 'end_time', 'duration', 'exclusive', 
+    'guid', 'agent_attributes', 'user_attributes'])
 
+_GraphQLResolverNode = namedtuple('_GraphQLNode',
+    ['field_name', 'children', 'start_time', 'end_time', 'duration', 
+    'exclusive', 'guid', 'agent_attributes', 'user_attributes'])
 
-class GraphQLNode(_GraphQLNode, GenericNodeMixin):
-
+class GraphQLNodeMixin(GenericNodeMixin):
     @property
     def product(self):
         return "GraphQL"
 
+    def trace_node(self, stats, root, connections):
+        name = root.string_table.cache(self.name)
+
+        start_time = newrelic.core.trace_node.node_start_time(root, self)
+        end_time = newrelic.core.trace_node.node_end_time(root, self)
+
+        root.trace_node_count += 1
+
+        children = []
+
+        # Now for the children
+
+        for child in self.children:
+            if root.trace_node_count > root.trace_node_limit:
+                break
+            children.append(child.trace_node(stats, root, connections))
+
+        # Agent attributes
+        params = self.get_trace_segment_params(root.settings)
+
+        return newrelic.core.trace_node.TraceNode(start_time=start_time,
+                end_time=end_time, name=name, params=params, children=children,
+                label=None)
+
+class GraphQLResolverNode(_GraphQLResolverNode, GraphQLNodeMixin):
     @property
-    def operation(self):
-        return "select"
+    def name(self):
+        field_name = self.field_name or "<unknown>"
+        product = self.product
 
+        name = 'GraphQL/resolve/%s/%s' % (product, field_name)
+
+        return name
 
     def time_metrics(self, stats, root, parent):
         """Return a generator yielding the timed metrics for this
         database node as well as all the child nodes.
         """
 
-        field_name = self.field_name
+        field_name = self.field_name or "<unknown>"
         product = self.product
-        operation = self.operation or 'other'
 
         # Determine the scoped metric
-        operation_metric_name = 'GraphQL/operation/%s/%s' % (product,
-                operation)
 
         field_resolver_metric_name = 'GraphQL/resolve/%s/%s' % (product, field_name)
 
-        scoped_metric_name = operation_metric_name
-
         yield TimeMetric(name=field_resolver_metric_name, scope=root.path, duration=self.duration,
                          exclusive=self.exclusive)
 
+        yield TimeMetric(name=field_resolver_metric_name, scope='', duration=self.duration,
+                         exclusive=self.exclusive)
+
+        # Now for the children
+
+        for child in self.children:
+            for metric in child.time_metrics(stats, root, self):
+                yield metric
+
+
+class GraphQLOperationNode(_GraphQLOperationNode, GraphQLNodeMixin):
+    @property
+    def name(self):
+        operation_type = self.operation_type or "<unknown>"
+        operation_name = self.operation_name or "<anonymous>"
+        deepest_path = self.deepest_path or "<unknown>"
+        product = self.product
+
+        name = 'GraphQL/operation/%s/%s/%s/%s' % (product, operation_type,
+                operation_name, deepest_path)
+
+        return name
+
+    def time_metrics(self, stats, root, parent):
+        """Return a generator yielding the timed metrics for this
+        database node as well as all the child nodes.
+
+        """
+
+        operation_type = self.operation_type or "<unknown>"
+        operation_name = self.operation_name or "<anonymous>"
+        deepest_path = self.deepest_path or "<unknown>"
+        product = self.product
+
+        # Determine the scoped metric
+
+        operation_metric_name = 'GraphQL/operation/%s/%s/%s/%s' % (product,
+                operation_type, operation_name, deepest_path)
+
+        scoped_metric_name = operation_metric_name
+
         yield TimeMetric(name=scoped_metric_name, scope=root.path,
                     duration=self.duration, exclusive=self.exclusive)
 
@@ -89,37 +154,8 @@ def time_metrics(self, stats, root, parent):
         yield TimeMetric(name=operation_metric_name, scope='',
                 duration=self.duration, exclusive=self.exclusive)
 
-        yield TimeMetric(name=field_resolver_metric_name, scope='', duration=self.duration,
-                         exclusive=self.exclusive)
-
-
-    def trace_node(self, stats, root, connections):
-        name = root.string_table.cache(self.name)
-
-        start_time = newrelic.core.trace_node.node_start_time(root, self)
-        end_time = newrelic.core.trace_node.node_end_time(root, self)
-
-        root.trace_node_count += 1
-
-        children = []
-
-        # Agent attributes
-        params = self.get_trace_segment_params(root.settings)
-
-        return newrelic.core.trace_node.TraceNode(start_time=start_time,
-                end_time=end_time, name=name, params=params, children=children,
-                label=None)
-
-    @property
-    def name(self):
-        product = self.product
-        target = "test"
-        operation = self.operation or 'other'
-
-        if target:
-            name = 'GraphQL/statement/%s/%s/%s' % (product, target,
-                    operation)
-        else:
-            name = 'GraphQL/operation/%s/%s' % (product, operation)
+        # Now for the children
 
-        return name
+        for child in self.children:
+            for metric in child.time_metrics(stats, root, self):
+                yield metric