From d0310d1b26ec7be3996c59bc3c690e971aed1ea9 Mon Sep 17 00:00:00 2001 From: Emily Stolfo Date: Mon, 19 Jul 2021 13:48:47 -0400 Subject: [PATCH 1/8] Support composite spans in the intake API --- .../TestPublishIntegrationSpans.approved.json | 140 ++++++++++++++++++ docs/spec/v2/span.json | 28 ++++ model/modeldecoder/rumv3/transaction_test.go | 1 + model/modeldecoder/v2/decoder.go | 13 ++ model/modeldecoder/v2/model.go | 16 ++ model/modeldecoder/v2/model_generated.go | 38 ++++- model/modeldecoder/v2/model_test.go | 5 + model/span.go | 21 +++ model/span_test.go | 8 +- .../testIntakeIntegrationSpans.approved.json | 125 ++++++++++++++++ testdata/intake-v2/spans.ndjson | 1 + 11 files changed, 394 insertions(+), 2 deletions(-) diff --git a/beater/test_approved_es_documents/TestPublishIntegrationSpans.approved.json b/beater/test_approved_es_documents/TestPublishIntegrationSpans.approved.json index ab3187f2671..d3efacded18 100644 --- a/beater/test_approved_es_documents/TestPublishIntegrationSpans.approved.json +++ b/beater/test_approved_es_documents/TestPublishIntegrationSpans.approved.json @@ -893,6 +893,146 @@ "id": "123", "name": "john" } + }, + { + "@timestamp": "2021-07-06T11:58:05.682Z", + "agent": { + "name": "elastic-node", + "version": "3.14.0" + }, + "cloud": { + "account": { + "id": "account_id", + "name": "account_name" + }, + "availability_zone": "cloud_availability_zone", + "instance": { + "id": "instance_id", + "name": "instance_name" + }, + "machine": { + "type": "machine_type" + }, + "project": { + "id": "project_id", + "name": "project_name" + }, + "provider": "cloud_provider", + "region": "cloud_region", + "service": { + "name": "lambda" + } + }, + "container": { + "id": "container-id" + }, + "ecs": { + "version": "1.10.0" + }, + "event": { + "outcome": "success" + }, + "host": { + "architecture": "x64", + "hostname": "node-name", + "ip": "127.0.0.1", + "name": "node-name", + "os": { + "platform": "darwin" + } + }, + "kubernetes": { + "namespace": "namespace1", + "node": { + "name": "node-name" + }, + "pod": { + "name": "pod-name", + "uid": "pod-uid" + } + }, + "labels": { + "tag1": "label1" + }, + "observer": { + "ephemeral_id": "00000000-0000-0000-0000-000000000000", + "hostname": "", + "id": "fbba762a-14dd-412c-b7e9-b79f903eb492", + "type": "test-apm-server", + "version": "1.2.3", + "version_major": 1 + }, + "parent": { + "id": "abcdef0123456789" + }, + "process": { + "args": [ + "node", + "server.js" + ], + "pid": 1234, + "ppid": 6789, + "title": "node" + }, + "processor": { + "event": "span", + "name": "transaction" + }, + "service": { + "environment": "staging", + "framework": { + "name": "Express", + "version": "1.2.3" + }, + "language": { + "name": "ecmascript", + "version": "8" + }, + "name": "backendspans", + "node": { + "name": "container-id" + }, + "runtime": { + "name": "node", + "version": "8.0.0" + }, + "version": "5.1.3" + }, + "span": { + "action": "query", + "composite": { + "compression_strategy": "exact_match", + "count": 10, + "sum": { + "us": 32592 + } + }, + "duration": { + "us": 3781 + }, + "id": "abcdef01234567", + "name": "SELECT FROM p_details", + "start": { + "us": 2830 + }, + "subtype": "postgresql", + "type": "db" + }, + "timestamp": { + "us": 1625572685682272 + }, + "trace": { + "id": "edcbaf0123456789abcdef9876543210" + }, + "transaction": { + "id": "01af25874dec69dd" + }, + "user": { + "domain": "ldap://abc", + "email": "s@test.com", + "id": "123", + "name": "john" + } } ] } diff --git a/docs/spec/v2/span.json b/docs/spec/v2/span.json index 93a521ea601..5e7d6a60348 100644 --- a/docs/spec/v2/span.json +++ b/docs/spec/v2/span.json @@ -22,6 +22,34 @@ }, "minItems": 0 }, + "composite": { + "description": "Composite holds details on a group of spans represented by a single one.", + "type": [ + "null", + "object" + ], + "properties": { + "compression_strategy": { + "description": "A string value indicating which compression strategy was used. The valid values are `exact_match` and `same_kind`.", + "type": "string" + }, + "count": { + "description": "Count is the number of compressed spans the composite span represents. The minimum count is 2, as a composite span represents at least two spans.", + "type": "integer", + "minimum": 2 + }, + "sum": { + "description": "Sum is the durations of all compressed spans this composite span represents in milliseconds. Thus sum is the net duration of all the compressed spans while duration is the gross duration, including \"whitespace\" between the spans.", + "type": "number", + "minimum": 0 + } + }, + "required": [ + "count", + "sum", + "compression_strategy" + ] + }, "context": { "description": "Context holds arbitrary contextual information for the event.", "type": [ diff --git a/model/modeldecoder/rumv3/transaction_test.go b/model/modeldecoder/rumv3/transaction_test.go index b4e97cda713..8fca5aa222e 100644 --- a/model/modeldecoder/rumv3/transaction_test.go +++ b/model/modeldecoder/rumv3/transaction_test.go @@ -223,6 +223,7 @@ func TestDecodeMapToTransactionModel(t *testing.T) { "Metadata", // values not set for RUM v3 "ChildIDs", + "Composite", "DB", "Experimental", "HTTP.Response.Headers", diff --git a/model/modeldecoder/v2/decoder.go b/model/modeldecoder/v2/decoder.go index 4ae6517679f..94cff12f1b0 100644 --- a/model/modeldecoder/v2/decoder.go +++ b/model/modeldecoder/v2/decoder.go @@ -770,6 +770,19 @@ func mapToSpanModel(from *span, metadata *model.Metadata, reqTime time.Time, con out.Type = from.Type.Val } } + if from.Composite.IsSet() { + composite := model.Composite{} + if from.Composite.Count.IsSet() { + composite.Count = from.Composite.Count.Val + } + if from.Composite.Sum.IsSet() { + composite.Sum = from.Composite.Sum.Val + } + if from.Composite.CompressionStrategy.IsSet() { + composite.CompressionStrategy = from.Composite.CompressionStrategy.Val + } + out.Composite = &composite + } if len(from.ChildIDs) > 0 { out.ChildIDs = make([]string, len(from.ChildIDs)) copy(out.ChildIDs, from.ChildIDs) diff --git a/model/modeldecoder/v2/model.go b/model/modeldecoder/v2/model.go index 0673bc58e59..7f9679fb069 100644 --- a/model/modeldecoder/v2/model.go +++ b/model/modeldecoder/v2/model.go @@ -605,6 +605,8 @@ type span struct { Action nullable.String `json:"action" validate:"maxLength=1024"` // ChildIDs holds a list of successor transactions and/or spans. ChildIDs []string `json:"child_ids" validate:"maxLength=1024"` + // Composite holds details on a group of spans represented by a single one. + Composite spanComposite `json:"composite"` // Context holds arbitrary contextual information for the event. Context spanContext `json:"context"` // Duration of the span in milliseconds @@ -768,6 +770,20 @@ type stacktraceFrame struct { _ struct{} `validate:"requiredAnyOf=classname;filename"` } +type spanComposite struct { + // Count is the number of compressed spans the composite span represents. + // The minimum count is 2, as a composite span represents at least two spans. + Count nullable.Int `json:"count" validate:"required,min=2"` + // Sum is the durations of all compressed spans this composite span + // represents in milliseconds. Thus sum is the net duration of all the + // compressed spans while duration is the gross duration, including + // "whitespace" between the spans. + Sum nullable.Float64 `json:"sum" validate:"required,min=0"` + // A string value indicating which compression strategy was used. The valid + // values are `exact_match` and `same_kind`. + CompressionStrategy nullable.String `json:"compression_strategy" validate:"required"` +} + type transaction struct { // Context holds arbitrary contextual information for the event. Context context `json:"context"` diff --git a/model/modeldecoder/v2/model_generated.go b/model/modeldecoder/v2/model_generated.go index 8950d27476b..353cf667652 100644 --- a/model/modeldecoder/v2/model_generated.go +++ b/model/modeldecoder/v2/model_generated.go @@ -1482,12 +1482,13 @@ func (val *spanRoot) validate() error { } func (val *span) IsSet() bool { - return val.Action.IsSet() || (len(val.ChildIDs) > 0) || val.Context.IsSet() || val.Duration.IsSet() || val.ID.IsSet() || val.Name.IsSet() || val.Outcome.IsSet() || val.ParentID.IsSet() || val.SampleRate.IsSet() || (len(val.Stacktrace) > 0) || val.Start.IsSet() || val.Subtype.IsSet() || val.Sync.IsSet() || val.Timestamp.IsSet() || val.TraceID.IsSet() || val.TransactionID.IsSet() || val.Type.IsSet() + return val.Action.IsSet() || (len(val.ChildIDs) > 0) || val.Composite.IsSet() || val.Context.IsSet() || val.Duration.IsSet() || val.ID.IsSet() || val.Name.IsSet() || val.Outcome.IsSet() || val.ParentID.IsSet() || val.SampleRate.IsSet() || (len(val.Stacktrace) > 0) || val.Start.IsSet() || val.Subtype.IsSet() || val.Sync.IsSet() || val.Timestamp.IsSet() || val.TraceID.IsSet() || val.TransactionID.IsSet() || val.Type.IsSet() } func (val *span) Reset() { val.Action.Reset() val.ChildIDs = val.ChildIDs[:0] + val.Composite.Reset() val.Context.Reset() val.Duration.Reset() val.ID.Reset() @@ -1520,6 +1521,9 @@ func (val *span) validate() error { return fmt.Errorf("'child_ids': validation rule 'maxLength(1024)' violated") } } + if err := val.Composite.validate(); err != nil { + return errors.Wrapf(err, "composite") + } if err := val.Context.validate(); err != nil { return errors.Wrapf(err, "context") } @@ -1588,6 +1592,38 @@ func (val *span) validate() error { return nil } +func (val *spanComposite) IsSet() bool { + return val.Count.IsSet() || val.Sum.IsSet() || val.CompressionStrategy.IsSet() +} + +func (val *spanComposite) Reset() { + val.Count.Reset() + val.Sum.Reset() + val.CompressionStrategy.Reset() +} + +func (val *spanComposite) validate() error { + if !val.IsSet() { + return nil + } + if val.Count.IsSet() && val.Count.Val < 2 { + return fmt.Errorf("'count': validation rule 'min(2)' violated") + } + if !val.Count.IsSet() { + return fmt.Errorf("'count' required") + } + if val.Sum.IsSet() && val.Sum.Val < 0 { + return fmt.Errorf("'sum': validation rule 'min(0)' violated") + } + if !val.Sum.IsSet() { + return fmt.Errorf("'sum' required") + } + if !val.CompressionStrategy.IsSet() { + return fmt.Errorf("'compression_strategy' required") + } + return nil +} + func (val *spanContext) IsSet() bool { return val.Database.IsSet() || val.Destination.IsSet() || val.Experimental.IsSet() || val.HTTP.IsSet() || val.Message.IsSet() || val.Service.IsSet() || (len(val.Tags) > 0) } diff --git a/model/modeldecoder/v2/model_test.go b/model/modeldecoder/v2/model_test.go index 906da414430..8a735ac3caf 100644 --- a/model/modeldecoder/v2/model_test.go +++ b/model/modeldecoder/v2/model_test.go @@ -508,6 +508,8 @@ func TestSpanRequiredValidationRules(t *testing.T) { var event span modeldecodertest.InitStructValues(&event) event.Outcome.Set("failure") + // Composite.Count must be > 1 + event.Composite.Count.Set(2) // test vanilla struct is valid require.NoError(t, event.validate()) @@ -521,6 +523,9 @@ func TestSpanRequiredValidationRules(t *testing.T) { "parent_id": nil, "trace_id": nil, "type": nil, + "composite.count": nil, + "composite.sum": nil, + "composite.compression_strategy": nil, } cb := assertRequiredFn(t, requiredKeys, event.validate) modeldecodertest.SetZeroStructValue(&event, cb) diff --git a/model/span.go b/model/span.go index 33c0449a549..218570e6e4d 100644 --- a/model/span.go +++ b/model/span.go @@ -68,6 +68,7 @@ type Span struct { URL string Destination *Destination DestinationService *DestinationService + Composite *Composite Experimental interface{} @@ -102,6 +103,13 @@ type DestinationService struct { Resource string } +// Composite holds details on a group of spans compressed into one. +type Composite struct { + Count int + Sum float64 + CompressionStrategy string +} + func (db *DB) fields() common.MapStr { if db == nil { return nil @@ -143,6 +151,18 @@ func (d *DestinationService) fields() common.MapStr { return common.MapStr(fields) } +func (c *Composite) fields() common.MapStr { + if c == nil { + return nil + } + var fields mapStr + fields.set("count", c.Count) + fields.set("sum", utility.MillisAsMicros(c.Sum)) + fields.set("compression_strategy", c.CompressionStrategy) + + return common.MapStr(fields) +} + func (e *Span) toBeatEvent(ctx context.Context) beat.Event { spanTransformations.Inc() if frames := len(e.Stacktrace); frames > 0 { @@ -214,6 +234,7 @@ func (e *Span) fields(ctx context.Context) common.MapStr { } fields.maybeSetMapStr("db", e.DB.fields()) fields.maybeSetMapStr("message", e.Message.Fields()) + fields.maybeSetMapStr("composite", e.Composite.fields()) if destinationServiceFields := e.DestinationService.fields(); len(destinationServiceFields) > 0 { common.MapStr(fields).Put("destination.service", destinationServiceFields) } diff --git a/model/span_test.go b/model/span_test.go index 074ecaf27f1..0cdbbbcf376 100644 --- a/model/span_test.go +++ b/model/span_test.go @@ -118,7 +118,8 @@ func TestSpanTransform(t *testing.T) { Name: destServiceName, Resource: destServiceResource, }, - Message: &Message{QueueName: "users"}, + Message: &Message{QueueName: "users"}, + Composite: &Composite{Count: 10, Sum: 1.1, CompressionStrategy: "exact_match"}, }, Output: common.MapStr{ "span": common.MapStr{ @@ -153,6 +154,11 @@ func TestSpanTransform(t *testing.T) { }, }, "message": common.MapStr{"queue": common.MapStr{"name": "users"}}, + "composite": common.MapStr{ + "count": 10, + "sum": common.MapStr{"us": 1100}, + "compression_strategy": "exact_match", + }, }, "labels": common.MapStr{"label_a": 12, "label_b": "b", "c": 1}, "processor": common.MapStr{"event": "span", "name": "transaction"}, diff --git a/processor/stream/test_approved_es_documents/testIntakeIntegrationSpans.approved.json b/processor/stream/test_approved_es_documents/testIntakeIntegrationSpans.approved.json index 301d27c4e5b..e54fbaaaaf0 100644 --- a/processor/stream/test_approved_es_documents/testIntakeIntegrationSpans.approved.json +++ b/processor/stream/test_approved_es_documents/testIntakeIntegrationSpans.approved.json @@ -803,6 +803,131 @@ "id": "123", "name": "john" } + }, + { + "@timestamp": "2021-07-06T11:58:05.682Z", + "agent": { + "name": "elastic-node", + "version": "3.14.0" + }, + "cloud": { + "account": { + "id": "account_id", + "name": "account_name" + }, + "availability_zone": "cloud_availability_zone", + "instance": { + "id": "instance_id", + "name": "instance_name" + }, + "machine": { + "type": "machine_type" + }, + "project": { + "id": "project_id", + "name": "project_name" + }, + "provider": "cloud_provider", + "region": "cloud_region", + "service": { + "name": "lambda" + } + }, + "container": { + "id": "container-id" + }, + "event": { + "outcome": "success" + }, + "host": { + "architecture": "x64", + "hostname": "prod1.example.com", + "ip": "192.0.0.1", + "os": { + "platform": "darwin" + } + }, + "kubernetes": { + "namespace": "namespace1", + "node": { + "name": "node-name" + }, + "pod": { + "name": "pod-name", + "uid": "pod-uid" + } + }, + "labels": { + "tag1": "label1" + }, + "parent": { + "id": "abcdef0123456789" + }, + "process": { + "args": [ + "node", + "server.js" + ], + "pid": 1234, + "ppid": 6789, + "title": "node" + }, + "processor": { + "event": "span", + "name": "transaction" + }, + "service": { + "environment": "staging", + "framework": { + "name": "Express", + "version": "1.2.3" + }, + "language": { + "name": "ecmascript", + "version": "8" + }, + "name": "backendspans", + "runtime": { + "name": "node", + "version": "8.0.0" + }, + "version": "5.1.3" + }, + "span": { + "action": "query", + "composite": { + "compression_strategy": "exact_match", + "count": 10, + "sum": { + "us": 3592 + } + }, + "duration": { + "us": 3781 + }, + "id": "abcdef01234567", + "name": "SELECT FROM p_details", + "start": { + "us": 2830 + }, + "subtype": "postgresql", + "type": "db" + }, + "timestamp": { + "us": 1625572685682272 + }, + "trace": { + "id": "edcbaf0123456789abcdef9876543210" + }, + "transaction": { + "id": "01af25874dec69dd" + }, + "user": { + "domain": "ldap://abc", + "email": "s@test.com", + "id": "123", + "name": "john" + } } ] } diff --git a/testdata/intake-v2/spans.ndjson b/testdata/intake-v2/spans.ndjson index 6a3f54cb4d5..34c86b3e5ad 100644 --- a/testdata/intake-v2/spans.ndjson +++ b/testdata/intake-v2/spans.ndjson @@ -5,3 +5,4 @@ {"span": {"trace_id": "abcdef0123456789abcdef9876543210", "parent_id": "ababcdcdefefabde", "id": "abcde56a89012345", "transaction_id": null, "name": "get /api/types", "sync": false, "type": "request", "subtype": "http", "action": "call", "start": 0, "duration": 13.9802981, "stacktrace": null, "context": null }} {"span": {"trace_id": "abcdef0123456789abcdef9876543210", "parent_id": "abcdef0123456789", "id": "1234567890aaaade", "sync": true, "name": "SELECT FROM product_types", "type": "db.postgresql.query", "start": 2.83092, "duration": 3.781912, "stacktrace": [{ "filename": "net.js", "classname": "Core.js", "lineno": 547},{"filename": "file2.js", "lineno": 12, "post_context": [ " ins.currentTransaction = prev", "}"]}, { "function": "onread", "abs_path": "net.js", "filename": "net.js", "lineno": 547, "library_frame": true, "vars": { "key": "value" }, "module": "some module", "colno": 4, "context_line": "line3", "pre_context": [ " var trans = this.currentTransaction", "" ], "post_context": [ " ins.currentTransaction = prev", " return result"] }], "context": { "db": { "instance": "customers", "statement": "SELECT * FROM product_types WHERE user_id=?", "type": "sql", "user": "readonly_user", "link": "other.db.com", "rows_affected": 2}, "http": { "url": "http://localhost:8000", "status_code":200, "response":{"headers": { "content-type": null }, "status_code":200,"transfer_size":300.12,"encoded_body_size":356,"decoded_body_size":401}, "method": "GET" }, "destination": {"address": "0:0::0:1", "port": 5432, "service": {"type": "db", "name": "postgresql", "resource": "postgresql"}}, "service":{"name":"service1","agent":{"version":"2.2","name":"elastic-ruby", "ephemeral_id": "justanid"}}}}} {"span": {"trace_id": "fdedef0123456789abcdef9876543210", "parent_id": "abcdef0123456789", "id": "00xxx12312312312", "transaction_id": "01af25874dec69dd", "name": "Rabbitmq receive", "type": "messaging", "subtype": "JMS", "action": "receive", "duration": 141.581, "timestamp": 1532976822281000, "context": {"destination": {"address": "0:0::0:1"}, "message": {"queue": { "name": "new_users"}, "age":{"ms": 1577958057123}}}}} +{"span": {"trace_id": "edcbaf0123456789abcdef9876543210", "parent_id": "abcdef0123456789", "id": "abcdef01234567", "transaction_id": "01af25874dec69dd", "name": "SELECT FROM p_details", "type": "db.postgresql.query","start": 2.83092, "duration": 3.781912, "timestamp": 1625572685682272,"composite":{"count":10, "sum": 3.592981,"compression_strategy": "exact_match"},"outcome": "success"}} From 93332d267100ad80b0888c6d5e4ac2fea0f866f3 Mon Sep 17 00:00:00 2001 From: Emily Stolfo Date: Mon, 19 Jul 2021 13:54:36 -0400 Subject: [PATCH 2/8] Update documentation for new composite span fields in ES --- .../apm/data_stream/traces/fields/fields.yml | 12 +++++++ apmpackage/apm/docs/README.md | 3 ++ docs/fields.asciidoc | 32 +++++++++++++++++++ include/fields.go | 2 +- model/span/_meta/fields.yml | 25 +++++++++++++++ 5 files changed, 73 insertions(+), 1 deletion(-) diff --git a/apmpackage/apm/data_stream/traces/fields/fields.yml b/apmpackage/apm/data_stream/traces/fields/fields.yml index e5d53e80a78..cb3424afe17 100644 --- a/apmpackage/apm/data_stream/traces/fields/fields.yml +++ b/apmpackage/apm/data_stream/traces/fields/fields.yml @@ -113,6 +113,18 @@ type: keyword description: | The specific kind of event within the sub-type represented by the span (e.g. query, connect) +- name: span.composite.compression_strategy + type: keyword + description: | + The compression strategy that was used. +- name: span.composite.count + type: long + description: | + Number of compressed spans the composite span represents. +- name: span.composite.sum.us + type: long + description: | + Sum of the durations of the compression spans, in microseconds. - name: span.db.link type: keyword description: | diff --git a/apmpackage/apm/docs/README.md b/apmpackage/apm/docs/README.md index eccc4365c32..40b68d17134 100644 --- a/apmpackage/apm/docs/README.md +++ b/apmpackage/apm/docs/README.md @@ -131,6 +131,9 @@ Traces are written to `traces-apm.*` indices. |source.ip|IP address of the source of a recorded event. This is typically obtained from a request's X-Forwarded-For or the X-Real-IP header or falls back to a given configuration for remote address.|ip| ![](https://doc-icons.s3.us-east-2.amazonaws.com/icon-yes.png) | |source.port|Port of the source.|long| ![](https://doc-icons.s3.us-east-2.amazonaws.com/icon-yes.png) | |span.action|The specific kind of event within the sub-type represented by the span (e.g. query, connect)|keyword| ![](https://doc-icons.s3.us-east-2.amazonaws.com/icon-no.png) | +|span.composite.compression\_strategy|The compression strategy that was used.|keyword| ![](https://doc-icons.s3.us-east-2.amazonaws.com/icon-no.png) | +|span.composite.count|Number of compressed spans the composite span represents.|long| ![](https://doc-icons.s3.us-east-2.amazonaws.com/icon-no.png) | +|span.composite.sum.us|Sum of the durations of the compression spans, in microseconds.|long| ![](https://doc-icons.s3.us-east-2.amazonaws.com/icon-no.png) | |span.db.link|Database link.|keyword| ![](https://doc-icons.s3.us-east-2.amazonaws.com/icon-no.png) | |span.db.rows\_affected|Number of rows affected by the database statement.|long| ![](https://doc-icons.s3.us-east-2.amazonaws.com/icon-no.png) | |span.destination.service.name|Identifier for the destination service (e.g. 'http://elastic.co', 'elasticsearch', 'rabbitmq') DEPRECATED: this field will be removed in a future release|keyword| ![](https://doc-icons.s3.us-east-2.amazonaws.com/icon-no.png) | diff --git a/docs/fields.asciidoc b/docs/fields.asciidoc index 37a87aae4bf..75c6db03aee 100644 --- a/docs/fields.asciidoc +++ b/docs/fields.asciidoc @@ -3927,6 +3927,38 @@ type: long -- + +*`span.composite.count`*:: ++ +-- +Number of compressed spans the composite span represents. + + +type: long + +-- + + +*`span.composite.sum.us`*:: ++ +-- +Sum of the durations of the compression spans, in microseconds. + + +type: long + +-- + +*`span.composite.compression_strategy`*:: ++ +-- +The compression strategy that was used. + + +type: keyword + +-- + [[exported-fields-apm-span-metrics-xpack]] == APM Span Metrics fields diff --git a/include/fields.go b/include/fields.go index 6beea5824cd..e0cf4f853b3 100644 --- a/include/fields.go +++ b/include/fields.go @@ -32,5 +32,5 @@ func init() { // AssetBuildFieldsFieldsYml returns asset data. // This is the base64 encoded gzipped contents of build/fields/fields.yml. func AssetBuildFieldsFieldsYml() string { - return "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" + return "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" } diff --git a/model/span/_meta/fields.yml b/model/span/_meta/fields.yml index 401c23d6131..dd3ce24ced5 100644 --- a/model/span/_meta/fields.yml +++ b/model/span/_meta/fields.yml @@ -865,3 +865,28 @@ type: long description: > Age of a message in milliseconds. + + - name: composite + type: group + dynamic: false + fields: + + - name: count + type: long + description: > + Number of compressed spans the composite span represents. + + - name: sum + type: group + fields: + + - name: us + type: long + count: 1 + description: > + Sum of the durations of the compression spans, in microseconds. + + - name: compression_strategy + type: keyword + description: > + The compression strategy that was used. From 598e5730a3555ddddb66898bc616473335d5d621 Mon Sep 17 00:00:00 2001 From: Emily Stolfo Date: Mon, 19 Jul 2021 13:56:50 -0400 Subject: [PATCH 3/8] Update approvals file --- .../TestPublishIntegrationSpans.approved.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/beater/test_approved_es_documents/TestPublishIntegrationSpans.approved.json b/beater/test_approved_es_documents/TestPublishIntegrationSpans.approved.json index d3efacded18..3c79fb1aba8 100644 --- a/beater/test_approved_es_documents/TestPublishIntegrationSpans.approved.json +++ b/beater/test_approved_es_documents/TestPublishIntegrationSpans.approved.json @@ -1004,7 +1004,7 @@ "compression_strategy": "exact_match", "count": 10, "sum": { - "us": 32592 + "us": 3592 } }, "duration": { From edaedccbaefdfc3fb12bd93e440750f6d532c12a Mon Sep 17 00:00:00 2001 From: Emily Stolfo Date: Mon, 19 Jul 2021 14:14:06 -0400 Subject: [PATCH 4/8] Update duration and composite sum fields to be more realistic --- .../TestPublishIntegrationSpans.approved.json | 4 ++-- .../testIntakeIntegrationSpans.approved.json | 4 ++-- testdata/intake-v2/spans.ndjson | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/beater/test_approved_es_documents/TestPublishIntegrationSpans.approved.json b/beater/test_approved_es_documents/TestPublishIntegrationSpans.approved.json index 3c79fb1aba8..2a45b5e24b7 100644 --- a/beater/test_approved_es_documents/TestPublishIntegrationSpans.approved.json +++ b/beater/test_approved_es_documents/TestPublishIntegrationSpans.approved.json @@ -1004,11 +1004,11 @@ "compression_strategy": "exact_match", "count": 10, "sum": { - "us": 3592 + "us": 359298 } }, "duration": { - "us": 3781 + "us": 378191 }, "id": "abcdef01234567", "name": "SELECT FROM p_details", diff --git a/processor/stream/test_approved_es_documents/testIntakeIntegrationSpans.approved.json b/processor/stream/test_approved_es_documents/testIntakeIntegrationSpans.approved.json index e54fbaaaaf0..52760954679 100644 --- a/processor/stream/test_approved_es_documents/testIntakeIntegrationSpans.approved.json +++ b/processor/stream/test_approved_es_documents/testIntakeIntegrationSpans.approved.json @@ -899,11 +899,11 @@ "compression_strategy": "exact_match", "count": 10, "sum": { - "us": 3592 + "us": 359298 } }, "duration": { - "us": 3781 + "us": 378191 }, "id": "abcdef01234567", "name": "SELECT FROM p_details", diff --git a/testdata/intake-v2/spans.ndjson b/testdata/intake-v2/spans.ndjson index 34c86b3e5ad..bdd94f33d17 100644 --- a/testdata/intake-v2/spans.ndjson +++ b/testdata/intake-v2/spans.ndjson @@ -5,4 +5,4 @@ {"span": {"trace_id": "abcdef0123456789abcdef9876543210", "parent_id": "ababcdcdefefabde", "id": "abcde56a89012345", "transaction_id": null, "name": "get /api/types", "sync": false, "type": "request", "subtype": "http", "action": "call", "start": 0, "duration": 13.9802981, "stacktrace": null, "context": null }} {"span": {"trace_id": "abcdef0123456789abcdef9876543210", "parent_id": "abcdef0123456789", "id": "1234567890aaaade", "sync": true, "name": "SELECT FROM product_types", "type": "db.postgresql.query", "start": 2.83092, "duration": 3.781912, "stacktrace": [{ "filename": "net.js", "classname": "Core.js", "lineno": 547},{"filename": "file2.js", "lineno": 12, "post_context": [ " ins.currentTransaction = prev", "}"]}, { "function": "onread", "abs_path": "net.js", "filename": "net.js", "lineno": 547, "library_frame": true, "vars": { "key": "value" }, "module": "some module", "colno": 4, "context_line": "line3", "pre_context": [ " var trans = this.currentTransaction", "" ], "post_context": [ " ins.currentTransaction = prev", " return result"] }], "context": { "db": { "instance": "customers", "statement": "SELECT * FROM product_types WHERE user_id=?", "type": "sql", "user": "readonly_user", "link": "other.db.com", "rows_affected": 2}, "http": { "url": "http://localhost:8000", "status_code":200, "response":{"headers": { "content-type": null }, "status_code":200,"transfer_size":300.12,"encoded_body_size":356,"decoded_body_size":401}, "method": "GET" }, "destination": {"address": "0:0::0:1", "port": 5432, "service": {"type": "db", "name": "postgresql", "resource": "postgresql"}}, "service":{"name":"service1","agent":{"version":"2.2","name":"elastic-ruby", "ephemeral_id": "justanid"}}}}} {"span": {"trace_id": "fdedef0123456789abcdef9876543210", "parent_id": "abcdef0123456789", "id": "00xxx12312312312", "transaction_id": "01af25874dec69dd", "name": "Rabbitmq receive", "type": "messaging", "subtype": "JMS", "action": "receive", "duration": 141.581, "timestamp": 1532976822281000, "context": {"destination": {"address": "0:0::0:1"}, "message": {"queue": { "name": "new_users"}, "age":{"ms": 1577958057123}}}}} -{"span": {"trace_id": "edcbaf0123456789abcdef9876543210", "parent_id": "abcdef0123456789", "id": "abcdef01234567", "transaction_id": "01af25874dec69dd", "name": "SELECT FROM p_details", "type": "db.postgresql.query","start": 2.83092, "duration": 3.781912, "timestamp": 1625572685682272,"composite":{"count":10, "sum": 3.592981,"compression_strategy": "exact_match"},"outcome": "success"}} +{"span": {"trace_id": "edcbaf0123456789abcdef9876543210", "parent_id": "abcdef0123456789", "id": "abcdef01234567", "transaction_id": "01af25874dec69dd", "name": "SELECT FROM p_details", "type": "db.postgresql.query","start": 2.83092, "duration": 378.1912, "timestamp": 1625572685682272,"composite":{"count":10, "sum": 359.2981,"compression_strategy": "exact_match"},"outcome": "success"}} From 3429db69b335c81bfdcf7c35691aceda80f352a4 Mon Sep 17 00:00:00 2001 From: Emily Stolfo Date: Mon, 19 Jul 2021 14:16:02 -0400 Subject: [PATCH 5/8] Update changelog --- changelogs/head.asciidoc | 1 + 1 file changed, 1 insertion(+) diff --git a/changelogs/head.asciidoc b/changelogs/head.asciidoc index e77bfe7652f..fd5dccb62db 100644 --- a/changelogs/head.asciidoc +++ b/changelogs/head.asciidoc @@ -20,6 +20,7 @@ https://github.com/elastic/apm-server/compare/7.13\...master[View commits] [float] ==== Intake API Changes +* Add support for composite spans in the intake API {pull}5661[5661] [float] ==== Added From b827b2b69a45f0995dbf035b1043480a25d6e944 Mon Sep 17 00:00:00 2001 From: Emily Stolfo Date: Tue, 20 Jul 2021 11:17:31 -0400 Subject: [PATCH 6/8] Fix minor typo in composite.sum field --- apmpackage/apm/data_stream/traces/fields/fields.yml | 2 +- apmpackage/apm/docs/README.md | 2 +- docs/fields.asciidoc | 2 +- include/fields.go | 2 +- model/span/_meta/fields.yml | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/apmpackage/apm/data_stream/traces/fields/fields.yml b/apmpackage/apm/data_stream/traces/fields/fields.yml index cb3424afe17..577f63d359d 100644 --- a/apmpackage/apm/data_stream/traces/fields/fields.yml +++ b/apmpackage/apm/data_stream/traces/fields/fields.yml @@ -124,7 +124,7 @@ - name: span.composite.sum.us type: long description: | - Sum of the durations of the compression spans, in microseconds. + Sum of the durations of the compressed spans, in microseconds. - name: span.db.link type: keyword description: | diff --git a/apmpackage/apm/docs/README.md b/apmpackage/apm/docs/README.md index 40b68d17134..381a12982ad 100644 --- a/apmpackage/apm/docs/README.md +++ b/apmpackage/apm/docs/README.md @@ -133,7 +133,7 @@ Traces are written to `traces-apm.*` indices. |span.action|The specific kind of event within the sub-type represented by the span (e.g. query, connect)|keyword| ![](https://doc-icons.s3.us-east-2.amazonaws.com/icon-no.png) | |span.composite.compression\_strategy|The compression strategy that was used.|keyword| ![](https://doc-icons.s3.us-east-2.amazonaws.com/icon-no.png) | |span.composite.count|Number of compressed spans the composite span represents.|long| ![](https://doc-icons.s3.us-east-2.amazonaws.com/icon-no.png) | -|span.composite.sum.us|Sum of the durations of the compression spans, in microseconds.|long| ![](https://doc-icons.s3.us-east-2.amazonaws.com/icon-no.png) | +|span.composite.sum.us|Sum of the durations of the compressed spans, in microseconds.|long| ![](https://doc-icons.s3.us-east-2.amazonaws.com/icon-no.png) | |span.db.link|Database link.|keyword| ![](https://doc-icons.s3.us-east-2.amazonaws.com/icon-no.png) | |span.db.rows\_affected|Number of rows affected by the database statement.|long| ![](https://doc-icons.s3.us-east-2.amazonaws.com/icon-no.png) | |span.destination.service.name|Identifier for the destination service (e.g. 'http://elastic.co', 'elasticsearch', 'rabbitmq') DEPRECATED: this field will be removed in a future release|keyword| ![](https://doc-icons.s3.us-east-2.amazonaws.com/icon-no.png) | diff --git a/docs/fields.asciidoc b/docs/fields.asciidoc index 75c6db03aee..3dddd9d85b7 100644 --- a/docs/fields.asciidoc +++ b/docs/fields.asciidoc @@ -3942,7 +3942,7 @@ type: long *`span.composite.sum.us`*:: + -- -Sum of the durations of the compression spans, in microseconds. +Sum of the durations of the compressed spans, in microseconds. type: long diff --git a/include/fields.go b/include/fields.go index e0cf4f853b3..348b07a74ec 100644 --- a/include/fields.go +++ b/include/fields.go @@ -32,5 +32,5 @@ func init() { // AssetBuildFieldsFieldsYml returns asset data. // This is the base64 encoded gzipped contents of build/fields/fields.yml. func AssetBuildFieldsFieldsYml() string { - return "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" + return "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" } diff --git a/model/span/_meta/fields.yml b/model/span/_meta/fields.yml index dd3ce24ced5..1ac09556b61 100644 --- a/model/span/_meta/fields.yml +++ b/model/span/_meta/fields.yml @@ -884,7 +884,7 @@ type: long count: 1 description: > - Sum of the durations of the compression spans, in microseconds. + Sum of the durations of the compressed spans, in microseconds. - name: compression_strategy type: keyword From 24284d8a1219b4003bf6074181be05ee123e3543 Mon Sep 17 00:00:00 2001 From: Emily Stolfo Date: Tue, 20 Jul 2021 11:25:26 -0400 Subject: [PATCH 7/8] Update description of span duration and composite sum --- docs/spec/v2/span.json | 4 ++-- model/modeldecoder/v2/model.go | 7 +++---- 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/docs/spec/v2/span.json b/docs/spec/v2/span.json index 5e7d6a60348..99f5ea6d792 100644 --- a/docs/spec/v2/span.json +++ b/docs/spec/v2/span.json @@ -39,7 +39,7 @@ "minimum": 2 }, "sum": { - "description": "Sum is the durations of all compressed spans this composite span represents in milliseconds. Thus sum is the net duration of all the compressed spans while duration is the gross duration, including \"whitespace\" between the spans.", + "description": "Sum is the durations of all compressed spans this composite span represents in milliseconds.", "type": "number", "minimum": 0 } @@ -504,7 +504,7 @@ } }, "duration": { - "description": "Duration of the span in milliseconds", + "description": "Duration of the span in milliseconds. When the span is a composite one, duration is the gross duration, including \"whitespace\" in between spans.", "type": "number", "minimum": 0 }, diff --git a/model/modeldecoder/v2/model.go b/model/modeldecoder/v2/model.go index 7f9679fb069..f3217305c72 100644 --- a/model/modeldecoder/v2/model.go +++ b/model/modeldecoder/v2/model.go @@ -609,7 +609,8 @@ type span struct { Composite spanComposite `json:"composite"` // Context holds arbitrary contextual information for the event. Context spanContext `json:"context"` - // Duration of the span in milliseconds + // Duration of the span in milliseconds. When the span is a composite one, + // duration is the gross duration, including "whitespace" in between spans. Duration nullable.Float64 `json:"duration" validate:"required,min=0"` // ID holds the hex encoded 64 random bits ID of the event. ID nullable.String `json:"id" validate:"required,maxLength=1024"` @@ -775,9 +776,7 @@ type spanComposite struct { // The minimum count is 2, as a composite span represents at least two spans. Count nullable.Int `json:"count" validate:"required,min=2"` // Sum is the durations of all compressed spans this composite span - // represents in milliseconds. Thus sum is the net duration of all the - // compressed spans while duration is the gross duration, including - // "whitespace" between the spans. + // represents in milliseconds. Sum nullable.Float64 `json:"sum" validate:"required,min=0"` // A string value indicating which compression strategy was used. The valid // values are `exact_match` and `same_kind`. From f65e58303e5707b7ce9b483ca379c0bac9ff5d4f Mon Sep 17 00:00:00 2001 From: Emily Stolfo Date: Wed, 21 Jul 2021 07:56:08 -0400 Subject: [PATCH 8/8] Add note to Composite.Sum that it's in milliseconds --- model/span.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/model/span.go b/model/span.go index 218570e6e4d..19e4a241094 100644 --- a/model/span.go +++ b/model/span.go @@ -106,7 +106,7 @@ type DestinationService struct { // Composite holds details on a group of spans compressed into one. type Composite struct { Count int - Sum float64 + Sum float64 // milliseconds CompressionStrategy string }