Use kwarg

Author: marcotc

lib/datadog/tracing/transport/serializable_trace.rb

@@ -14,7 +14,7 @@ class SerializableTrace
 
         # @param trace [Datadog::Trace] the trace to serialize
         # @param native_events_supported [Boolean] whether the agent supports span events as a top-level field
-        def initialize(trace, native_events_supported)
+        def initialize(trace, native_events_supported:)
           @trace = trace
           @native_events_supported = native_events_supported
         end
@@ -29,13 +29,17 @@ def initialize(trace, native_events_supported)
         # @param packer [MessagePack::Packer] serialization buffer, can be +nil+ with JRuby
         def to_msgpack(packer = nil)
           # As of 1.3.3, JRuby implementation doesn't pass an existing packer
-          trace.spans.map { |s| SerializableSpan.new(s, @native_events_supported) }.to_msgpack(packer)
+          trace.spans.map do |s|
+            SerializableSpan.new(s, native_events_supported: @native_events_supported)
+          end.to_msgpack(packer)
         end
 
         # JSON serializer interface.
         # Used by older version of the transport.
         def to_json(*args)
-          trace.spans.map { |s| SerializableSpan.new(s, @native_events_supported).to_hash }.to_json(*args)
+          trace.spans.map do |s|
+            SerializableSpan.new(s, native_events_supported: @native_events_supported).to_hash
+          end.to_json(*args)
         end
       end
 
@@ -46,7 +50,7 @@ class SerializableSpan
 
         # @param span [Datadog::Span] the span to serialize
         # @param native_events_supported [Boolean] whether the agent supports span events as a top-level field
-        def initialize(span, native_events_supported)
+        def initialize(span, native_events_supported:)
           @span = span
           @trace_id = Tracing::Utils::TraceId.to_low_order(span.trace_id)
           @native_events_supported = native_events_supported

lib/datadog/tracing/transport/traces.rb

@@ -50,7 +50,7 @@ class Chunker
           #
           # @param encoder [Datadog::Core::Encoding::Encoder]
           # @param max_size [String] maximum acceptable payload size
-          def initialize(encoder, native_events_supported, max_size: DEFAULT_MAX_PAYLOAD_SIZE)
+          def initialize(encoder, native_events_supported:, max_size: DEFAULT_MAX_PAYLOAD_SIZE)
             @encoder = encoder
             @native_events_supported = native_events_supported
             @max_size = max_size
@@ -78,7 +78,7 @@ def encode_in_chunks(traces)
           private
 
           def encode_one(trace)
-            encoded = Encoder.encode_trace(encoder, trace, @native_events_supported)
+            encoded = Encoder.encode_trace(encoder, trace, native_events_supported: @native_events_supported)
 
             if encoded.size > max_size
               # This single trace is too large, we can't flush it
@@ -96,12 +96,12 @@ def encode_one(trace)
         module Encoder
           module_function
 
-          def encode_trace(encoder, trace, native_events_supported)
+          def encode_trace(encoder, trace, native_events_supported:)
             # Format the trace for transport
             TraceFormatter.format!(trace)
 
             # Make the trace serializable
-            serializable_trace = SerializableTrace.new(trace, native_events_supported)
+            serializable_trace = SerializableTrace.new(trace, native_events_supported: native_events_supported)
 
             # Encode the trace
             encoder.encode(serializable_trace).tap do |encoded|
@@ -128,7 +128,10 @@ def initialize(apis, default_api)
 
           def send_traces(traces)
             encoder = current_api.encoder
-            chunker = Datadog::Tracing::Transport::Traces::Chunker.new(encoder, native_events_supported?)
+            chunker = Datadog::Tracing::Transport::Traces::Chunker.new(
+              encoder,
+              native_events_supported: native_events_supported?
+            )
 
             responses = chunker.encode_in_chunks(traces.lazy).map do |encoded_traces, trace_count|
               request = Request.new(EncodedParcel.new(encoded_traces, trace_count))

sig/datadog/tracing/transport/serializable_trace.rbs

@@ -6,7 +6,7 @@ module Datadog
 
         attr_reader trace: TraceSegment
 
-        def initialize: (untyped trace, bool native_events_supported) -> void
+        def initialize: (untyped trace, native_events_supported: bool) -> void
 
         def to_msgpack: (?untyped? packer) -> untyped
 
@@ -19,7 +19,7 @@ module Datadog
 
         attr_reader span: Span
 
-        def initialize: (untyped span, bool native_events_supported) -> void
+        def initialize: (untyped span, native_events_supported: bool) -> void
 
         def to_msgpack: (?untyped? packer) -> untyped
 

sig/datadog/tracing/transport/traces.rbs

@@ -28,7 +28,7 @@ module Datadog
 
           attr_reader max_size: untyped
 
-          def initialize: (untyped encoder, bool native_events_supported, ?max_size: untyped) -> void
+          def initialize: (untyped encoder, native_events_supported: bool, ?max_size: untyped) -> void
 
           def encode_in_chunks: (untyped traces) -> untyped
 
@@ -38,7 +38,7 @@ module Datadog
         end
 
         module Encoder
-          def self?.encode_trace: (untyped encoder, untyped trace, bool native_events_supported) -> untyped
+          def self?.encode_trace: (untyped encoder, untyped trace, native_events_supported: bool) -> untyped
         end
 
         class Transport

spec/datadog/tracing/transport/serializable_trace_spec.rb

@@ -8,7 +8,7 @@
 require 'datadog/tracing/transport/serializable_trace'
 
 RSpec.describe Datadog::Tracing::Transport::SerializableTrace do
-  subject(:serializable_trace) { described_class.new(trace, native_events_supported) }
+  subject(:serializable_trace) { described_class.new(trace, native_events_supported: native_events_supported) }
 
   let(:trace) { Datadog::Tracing::TraceSegment.new(spans) }
   let(:native_events_supported) { false }

spec/datadog/tracing/transport/traces_spec.rb

@@ -60,7 +60,7 @@
 end
 
 RSpec.describe Datadog::Tracing::Transport::Traces::Chunker do
-  let(:chunker) { described_class.new(encoder, native_events_supported, max_size: max_size) }
+  let(:chunker) { described_class.new(encoder, native_events_supported: native_events_supported, max_size: max_size) }
   let(:encoder) { instance_double(Datadog::Core::Encoding::Encoder) }
   let(:native_events_supported) { double }
   let(:trace_encoder) { Datadog::Tracing::Transport::Traces::Encoder }
@@ -73,9 +73,21 @@
       let(:traces) { get_test_traces(3) }
 
       before do
-        allow(trace_encoder).to receive(:encode_trace).with(encoder, traces[0], native_events_supported).and_return('1')
-        allow(trace_encoder).to receive(:encode_trace).with(encoder, traces[1], native_events_supported).and_return('22')
-        allow(trace_encoder).to receive(:encode_trace).with(encoder, traces[2], native_events_supported).and_return('333')
+        allow(trace_encoder).to receive(:encode_trace).with(
+          encoder,
+          traces[0],
+          native_events_supported: native_events_supported
+        ).and_return('1')
+        allow(trace_encoder).to receive(:encode_trace).with(
+          encoder,
+          traces[1],
+          native_events_supported: native_events_supported
+        ).and_return('22')
+        allow(trace_encoder).to receive(:encode_trace).with(
+          encoder,
+          traces[2],
+          native_events_supported: native_events_supported
+        ).and_return('333')
         allow(encoder).to receive(:join) { |arr| arr.join(',') }
       end
 
@@ -178,8 +190,14 @@
     end
 
     before do
-      allow(Datadog::Tracing::Transport::Traces::Chunker).to receive(:new).with(encoder_v1, false).and_return(chunker)
-      allow(Datadog::Tracing::Transport::Traces::Chunker).to receive(:new).with(encoder_v2, false).and_return(chunker)
+      allow(Datadog::Tracing::Transport::Traces::Chunker).to receive(:new).with(
+        encoder_v1,
+        native_events_supported: false
+      ).and_return(chunker)
+      allow(Datadog::Tracing::Transport::Traces::Chunker).to receive(:new).with(
+        encoder_v2,
+        native_events_supported: false
+      ).and_return(chunker)
 
       allow(chunker).to receive(:encode_in_chunks).and_return(lazy_chunks)
 
@@ -272,7 +290,7 @@
           it 'does not encode native span events' do
             expect(Datadog::Tracing::Transport::Traces::Chunker).to receive(:new).with(
               encoder_v2,
-              false
+              native_events_supported: false
             ).and_return(chunker)
             send_traces
           end
@@ -282,7 +300,10 @@
           let(:native_events_supported) { true }
 
           it 'encodes native span events' do
-            expect(Datadog::Tracing::Transport::Traces::Chunker).to receive(:new).with(encoder_v2, true).and_return(chunker)
+            expect(Datadog::Tracing::Transport::Traces::Chunker).to receive(:new).with(
+              encoder_v2,
+              native_events_supported: true
+            ).and_return(chunker)
             send_traces
           end
         end
@@ -293,7 +314,7 @@
           it 'encodes native span events' do
             expect(Datadog::Tracing::Transport::Traces::Chunker).to receive(:new).with(
               encoder_v2,
-              false
+              native_events_supported: false
             ).and_return(chunker)
             send_traces
           end