github.com/instana/go-sensor@v1.62.2-0.20240520081010-4919868049e1/registered_span_test.go (about)

     1  // (c) Copyright IBM Corp. 2021
     2  // (c) Copyright Instana Inc. 2021
     3  
     4  package instana_test
     5  
     6  import (
     7  	"errors"
     8  	"strings"
     9  	"testing"
    10  
    11  	instana "github.com/instana/go-sensor"
    12  	"github.com/opentracing/opentracing-go"
    13  	"github.com/stretchr/testify/assert"
    14  )
    15  
    16  func TestRegisteredSpanType_ExtractData(t *testing.T) {
    17  	examples := map[string]struct {
    18  		Operation string
    19  		Expected  interface{}
    20  	}{
    21  		"net/http.Server": {
    22  			Operation: "g.http",
    23  			Expected:  instana.HTTPSpanData{},
    24  		},
    25  		"net/http.Client": {
    26  			Operation: "http",
    27  			Expected:  instana.HTTPSpanData{},
    28  		},
    29  		"golang.google.org/gppc.Server": {
    30  			Operation: "rpc-server",
    31  			Expected:  instana.RPCSpanData{},
    32  		},
    33  		"github.com/IBM/sarama": {
    34  			Operation: "kafka",
    35  			Expected:  instana.KafkaSpanData{},
    36  		},
    37  		"sdk": {
    38  			Operation: "test",
    39  			Expected:  instana.SDKSpanData{},
    40  		},
    41  		"aws lambda": {
    42  			Operation: "aws.lambda.entry",
    43  			Expected:  instana.AWSLambdaSpanData{},
    44  		},
    45  		"aws s3": {
    46  			Operation: "s3",
    47  			Expected:  instana.AWSS3SpanData{},
    48  		},
    49  		"aws sqs": {
    50  			Operation: "sqs",
    51  			Expected:  instana.AWSSQSSpanData{},
    52  		},
    53  		"aws sns": {
    54  			Operation: "sns",
    55  			Expected:  instana.AWSSNSSpanData{},
    56  		},
    57  		"aws dynamodb": {
    58  			Operation: "dynamodb",
    59  			Expected:  instana.AWSDynamoDBSpanData{},
    60  		},
    61  		"aws invoke": {
    62  			Operation: "aws.lambda.invoke",
    63  			Expected:  instana.AWSLambdaInvokeSpanData{},
    64  		},
    65  		"logger": {
    66  			Operation: "log.go",
    67  			Expected:  instana.LogSpanData{},
    68  		},
    69  		"mongodb": {
    70  			Operation: "mongo",
    71  			Expected:  instana.MongoDBSpanData{},
    72  		},
    73  		"postgresql": {
    74  			Operation: "postgres",
    75  			Expected:  instana.PostgreSQLSpanData{},
    76  		},
    77  		"redis": {
    78  			Operation: "redis",
    79  			Expected:  instana.RedisSpanData{},
    80  		},
    81  		"rabbitmq": {
    82  			Operation: "rabbitmq",
    83  			Expected:  instana.RabbitMQSpanData{},
    84  		},
    85  		"graphql server": {
    86  			Operation: "graphql.server",
    87  			Expected:  instana.GraphQLSpanData{},
    88  		},
    89  		"graphql client": {
    90  			Operation: "graphql.client",
    91  			Expected:  instana.GraphQLSpanData{},
    92  		},
    93  	}
    94  
    95  	for name, example := range examples {
    96  		t.Run(name, func(t *testing.T) {
    97  			recorder := instana.NewTestRecorder()
    98  			tracer := instana.NewTracerWithEverything(&instana.Options{AgentClient: alwaysReadyClient{}}, recorder)
    99  			defer instana.ShutdownSensor()
   100  
   101  			sp := tracer.StartSpan(example.Operation)
   102  			sp.Finish()
   103  
   104  			spans := recorder.GetQueuedSpans()
   105  			assert.Equal(t, 1, len(spans))
   106  			span := spans[0]
   107  
   108  			assert.IsType(t, example.Expected, span.Data)
   109  		})
   110  	}
   111  }
   112  
   113  func TestNewAWSLambdaSpanData(t *testing.T) {
   114  	examples := map[string]struct {
   115  		Tags     opentracing.Tags
   116  		Expected instana.AWSLambdaSpanData
   117  	}{
   118  		"aws:api.gateway": {
   119  			Tags: opentracing.Tags{
   120  				"http.protocol": "https",
   121  				"http.url":      "https://example.com/lambda",
   122  				"http.host":     "example.com",
   123  				"http.method":   "GET",
   124  				"http.path":     "/lambda",
   125  				"http.params":   "q=test&secret=classified",
   126  				"http.header":   map[string]string{"x-custom-header-1": "test"},
   127  				"http.status":   404,
   128  				"http.error":    "Not Found",
   129  			},
   130  			Expected: instana.AWSLambdaSpanData{
   131  				Snapshot: instana.AWSLambdaSpanTags{
   132  					ARN:              "lambda-arn-1",
   133  					Runtime:          "go",
   134  					Name:             "test-lambda",
   135  					Version:          "42",
   136  					Trigger:          "aws:api.gateway",
   137  					ColdStart:        true,
   138  					MillisecondsLeft: 5,
   139  					Error:            "Not Found",
   140  				},
   141  				HTTP: &instana.HTTPSpanTags{
   142  					URL:      "https://example.com/lambda",
   143  					Status:   404,
   144  					Method:   "GET",
   145  					Path:     "/lambda",
   146  					Params:   "q=test&secret=classified",
   147  					Headers:  map[string]string{"x-custom-header-1": "test"},
   148  					Host:     "example.com",
   149  					Protocol: "https",
   150  					Error:    "Not Found",
   151  				},
   152  			},
   153  		},
   154  		"aws:application.load.balancer": {
   155  			Tags: opentracing.Tags{
   156  				"http.protocol": "https",
   157  				"http.url":      "https://example.com/lambda",
   158  				"http.host":     "example.com",
   159  				"http.method":   "GET",
   160  				"http.path":     "/lambda",
   161  				"http.params":   "q=test&secret=classified",
   162  				"http.header":   map[string]string{"x-custom-header-1": "test"},
   163  				"http.status":   404,
   164  				"http.error":    "Not Found",
   165  			},
   166  			Expected: instana.AWSLambdaSpanData{
   167  				Snapshot: instana.AWSLambdaSpanTags{
   168  					ARN:              "lambda-arn-1",
   169  					Runtime:          "go",
   170  					Name:             "test-lambda",
   171  					Version:          "42",
   172  					Trigger:          "aws:application.load.balancer",
   173  					ColdStart:        true,
   174  					MillisecondsLeft: 5,
   175  					Error:            "Not Found",
   176  				},
   177  				HTTP: &instana.HTTPSpanTags{
   178  					URL:      "https://example.com/lambda",
   179  					Status:   404,
   180  					Method:   "GET",
   181  					Path:     "/lambda",
   182  					Params:   "q=test&secret=classified",
   183  					Headers:  map[string]string{"x-custom-header-1": "test"},
   184  					Host:     "example.com",
   185  					Protocol: "https",
   186  					Error:    "Not Found",
   187  				},
   188  			},
   189  		},
   190  		"aws:cloudwatch.events": {
   191  			Tags: opentracing.Tags{
   192  				"cloudwatch.events.id": "cw-event-1",
   193  				"cloudwatch.events.resources": []string{
   194  					"res1",
   195  					strings.Repeat("long ", 40) + "res2",
   196  					"res3",
   197  					"res4",
   198  				},
   199  			},
   200  			Expected: instana.AWSLambdaSpanData{
   201  				Snapshot: instana.AWSLambdaSpanTags{
   202  					ARN:              "lambda-arn-1",
   203  					Runtime:          "go",
   204  					Name:             "test-lambda",
   205  					Version:          "42",
   206  					Trigger:          "aws:cloudwatch.events",
   207  					ColdStart:        true,
   208  					MillisecondsLeft: 5,
   209  					Error:            "Not Found",
   210  					CloudWatch: &instana.AWSLambdaCloudWatchSpanTags{
   211  						Events: &instana.AWSLambdaCloudWatchEventTags{
   212  							ID: "cw-event-1",
   213  							Resources: []string{
   214  								"res1",
   215  								strings.Repeat("long ", 40),
   216  								"res3",
   217  							},
   218  							More: true,
   219  						},
   220  					},
   221  				},
   222  			},
   223  		},
   224  		"aws:cloudwatch.logs": {
   225  			Tags: opentracing.Tags{
   226  				"cloudwatch.logs.group":  "cw-log-group-1",
   227  				"cloudwatch.logs.stream": "cw-log-stream-1",
   228  				"cloudwatch.logs.events": []string{
   229  					"log1",
   230  					strings.Repeat("long ", 40) + "log2",
   231  					"log3",
   232  					"log4",
   233  				},
   234  				"cloudwatch.logs.decodingError": errors.New("none"),
   235  			},
   236  			Expected: instana.AWSLambdaSpanData{
   237  				Snapshot: instana.AWSLambdaSpanTags{
   238  					ARN:              "lambda-arn-1",
   239  					Runtime:          "go",
   240  					Name:             "test-lambda",
   241  					Version:          "42",
   242  					Trigger:          "aws:cloudwatch.logs",
   243  					ColdStart:        true,
   244  					MillisecondsLeft: 5,
   245  					Error:            "Not Found",
   246  					CloudWatch: &instana.AWSLambdaCloudWatchSpanTags{
   247  						Logs: &instana.AWSLambdaCloudWatchLogsTags{
   248  							Group:  "cw-log-group-1",
   249  							Stream: "cw-log-stream-1",
   250  							Events: []string{
   251  								"log1",
   252  								strings.Repeat("long ", 40),
   253  								"log3",
   254  							},
   255  							More:          true,
   256  							DecodingError: "none",
   257  						},
   258  					},
   259  				},
   260  			},
   261  		},
   262  		"aws:s3": {
   263  			Tags: opentracing.Tags{
   264  				"s3.events": []instana.AWSS3EventTags{
   265  					{Name: "event1", Bucket: "bucket1", Object: "object1"},
   266  					{Name: "event2", Bucket: "bucket2", Object: strings.Repeat("long ", 40) + "object2"},
   267  					{Name: "event3", Bucket: "bucket3"},
   268  					{Name: "event4", Bucket: "bucket4"},
   269  				},
   270  			},
   271  			Expected: instana.AWSLambdaSpanData{
   272  				Snapshot: instana.AWSLambdaSpanTags{
   273  					ARN:              "lambda-arn-1",
   274  					Runtime:          "go",
   275  					Name:             "test-lambda",
   276  					Version:          "42",
   277  					Trigger:          "aws:s3",
   278  					ColdStart:        true,
   279  					MillisecondsLeft: 5,
   280  					Error:            "Not Found",
   281  					S3: &instana.AWSLambdaS3SpanTags{
   282  						Events: []instana.AWSS3EventTags{
   283  							{Name: "event1", Bucket: "bucket1", Object: "object1"},
   284  							{Name: "event2", Bucket: "bucket2", Object: strings.Repeat("long ", 40)},
   285  							{Name: "event3", Bucket: "bucket3"},
   286  						},
   287  					},
   288  				},
   289  			},
   290  		},
   291  		"aws:sqs": {
   292  			Tags: opentracing.Tags{
   293  				"sqs.messages": []instana.AWSSQSMessageTags{{Queue: "q1"}, {Queue: "q2"}, {Queue: "q3"}, {Queue: "q4"}},
   294  			},
   295  			Expected: instana.AWSLambdaSpanData{
   296  				Snapshot: instana.AWSLambdaSpanTags{
   297  					ARN:              "lambda-arn-1",
   298  					Runtime:          "go",
   299  					Name:             "test-lambda",
   300  					Version:          "42",
   301  					Trigger:          "aws:sqs",
   302  					ColdStart:        true,
   303  					MillisecondsLeft: 5,
   304  					Error:            "Not Found",
   305  					SQS: &instana.AWSLambdaSQSSpanTags{
   306  						Messages: []instana.AWSSQSMessageTags{{Queue: "q1"}, {Queue: "q2"}, {Queue: "q3"}},
   307  					},
   308  				},
   309  			},
   310  		},
   311  	}
   312  
   313  	for trigger, example := range examples {
   314  		t.Run(trigger, func(t *testing.T) {
   315  			recorder := instana.NewTestRecorder()
   316  			tracer := instana.NewTracerWithEverything(&instana.Options{AgentClient: alwaysReadyClient{}}, recorder)
   317  			defer instana.ShutdownSensor()
   318  
   319  			sp := tracer.StartSpan("aws.lambda.entry", opentracing.Tags{
   320  				"lambda.arn":       "lambda-arn-1",
   321  				"lambda.name":      "test-lambda",
   322  				"lambda.version":   "42",
   323  				"lambda.trigger":   trigger,
   324  				"lambda.coldStart": true,
   325  				"lambda.msleft":    5,
   326  				"lambda.error":     "Not Found",
   327  			}, example.Tags)
   328  			sp.Finish()
   329  
   330  			spans := recorder.GetQueuedSpans()
   331  			assert.Equal(t, 1, len(spans))
   332  			span := spans[0]
   333  
   334  			assert.Equal(t, "aws.lambda.entry", span.Name)
   335  			assert.Equal(t, example.Expected, span.Data)
   336  		})
   337  	}
   338  }