signalfx-lambda 0.1.0 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: b7d5d079150c49b6b3b43e8a457cc5b4165ffe38e58dfa884a47f49f0a39bf6c
4
- data.tar.gz: ccd63f18a2caaf898bc40ce792930adc896e952a62a368730c40c6aa2e08f414
3
+ metadata.gz: 66109fc8dcb960d2debc31c6fc37b741bf3b4f55508c0b23c4032da3fe0e94ef
4
+ data.tar.gz: 0f0a82a5c16fe67584de6c1ad5e89ffa910166e2f4bfc7f9f7b494fe1374ae63
5
5
  SHA512:
6
- metadata.gz: c9af39140b055a4e4cb7728786b1c4a7de991b517e5302f448ccceadb165d3c32152a69817e1d978c4bb87e6ac6a38a01116c35495f228d97cb1e9b953b70686
7
- data.tar.gz: 7cb0f4ffe5863e00e2c63eec53d621f7c1c526eb20318534a0c56d0fee338a3aeb22ba8b2afce900585ab38dbf59f7e82e3a964634a5ea5c22bb097b5169fea6
6
+ metadata.gz: 8221f2148e1811c23b86bc365f2ac78c0335a48623a2fafcbabb8eb7eae5fe184af4405dde005a6331d4f40d410d42440c98294543e7cdaf82021e7c5478f3fe
7
+ data.tar.gz: 5dc457153fd2e4ea1acce699f9228ddfd37cad23a1657d1c73161c4533ec37fd64f39d644bad414884b32ceac2aed70eb6c9f7001af246f8c1b1092817757700
data/README.md CHANGED
@@ -1,7 +1,7 @@
1
1
  # SignalFx::Lambda
2
2
 
3
- This gem provides a simplified way to trace AWS Lambda functions written for the
4
- Ruby 2.5 runtime.
3
+ This gem provides a simplified way to get metrics and traces from AWS Lambda
4
+ functions written for the Ruby 2.5 runtime.
5
5
 
6
6
  ## Installation
7
7
 
@@ -34,32 +34,80 @@ def handler(event:, context:)
34
34
  JSON.generate(body)
35
35
  end
36
36
 
37
- SignalFx::Lambda::Tracing.register_handler(&method(:handler))
37
+ SignalFx::Lambda.register_handler(metrics: true, tracing: true, &method(:handler))
38
38
  ```
39
39
 
40
40
  `register_handler` will accept any block.
41
41
 
42
+ If passing in a block parameter, it must be the last argument.
43
+
44
+ It also takes these optional arguments:
45
+ - `metrics`: Enable reporting of metrics. Default: `true`
46
+ - `tracing`: Enable tracing. Default: `true`
47
+
48
+ ### Endpoint configuration
49
+
50
+ If metrics and traces should be reported to a common endpoint, as is the case
51
+ when using the Smart Gateway, a single environment variable should be set:
52
+
53
+ ```
54
+ SIGNALFX_ENDPOINT_URL=<gateway_url>
55
+ ```
56
+
57
+ If the component-specific URLs below are set, they will take precedence over
58
+ `SIGNALFX_ENDPOINT_URL` for those components.
59
+
60
+ By default, the metrics and traces will be reported to the `us0` realm. If you are
61
+ not in this realm you will need to set the `SIGNALFX_TRACING_URL` and
62
+ `SIGNALFX_METRICS_URL` environment variables, as described below.
63
+
42
64
  ### Tracer configuration
43
65
 
44
66
  The tracer used by the function is configured through environment variables:
45
67
 
46
68
  ```
47
69
  SIGNALFX_ACCESS_TOKEN
48
- SIGNALFX_INGEST_URL
49
70
  SIGNALFX_SERVICE_NAME
71
+ SIGNALFX_TRACING_URL
50
72
  ```
51
73
 
52
- In production, `SIGNALFX_INGEST_URL` should be pointing to your [Smart Gateway](https://docs.signalfx.com/en/latest/apm/apm-deployment/smart-gateway.html).
74
+ In production, `SIGNALFX_TRACING_URL` should be pointing to your [Smart Gateway](https://docs.signalfx.com/en/latest/apm/apm-deployment/smart-gateway.html).
53
75
  When pointing to the Smart Gateway, an access token is not needed. When not
54
76
  configured, the ingest URL defaults to `https://ingest.signalfx.com/v1/trace`,
55
77
  which requires an access token to be configured.
56
78
 
79
+ The default `SIGNALFX_TRACING_URL` points to the `us0` realm. If you are not in
80
+ this realm, you will need to set the environment variable to the correct realm
81
+ ingest endpoint (https://ingest.{REALM}.signalfx.com/v1/trace). To determine what realm
82
+ you are in, check your profile page in the SignalFx web application (click the
83
+ avatar in the upper right and click My Profile).
84
+
57
85
  The tracer will be persisted across invocations to the same context, reducing
58
86
  the time needed for tracer initialization.
59
87
 
88
+ ### SignalFx client configuration
89
+
90
+ The SignalFx client requires the following environment variables to be set:
91
+
92
+ ```
93
+ SIGNALFX_ACCESS_TOKEN
94
+ SIGNALFX_METRICS_URL
95
+ ```
96
+
97
+ When `SIGNALFX_METRICS_URL` is pointing to a Smart Gateway in production, the
98
+ access token is not needed.
99
+
100
+ The metrics URL will default to `https://ingest.signalfx.com` when not configured.
101
+
102
+ The default `SIGNALFX_METRICS_URL` points to the `us0` realm. If you are not in
103
+ this realm, you will need to set the environment variable to the correct realm
104
+ ingest endpoint (https://ingest.{REALM}.signalfx.com). To determine what realm
105
+ you are in, check your profile page in the SignalFx web application (click the
106
+ avatar in the upper right and click My Profile).
107
+
60
108
  ## Trace and tags
61
109
 
62
- The wrapper will generate a single span per function invocation. This span will
110
+ The wrapper will generate a trace per function invocation. The parent span will
63
111
  be named with the pattern `lambda_ruby_<function_name>`. The span prefix can be
64
112
  optionally configured with the `SIGNALFX_SPAN_PREFIX` environment variable:
65
113
 
@@ -82,11 +130,39 @@ Each span will also have the following tags:
82
130
 
83
131
  If a `qualifier` is present in the ARN, depending on the resource type, either `aws_function_qualifier` or `event_source_mappings` will be tagged.
84
132
 
85
- ## Manual Tracing
133
+ ## Metrics
134
+
135
+ When metrics are enabled, the following datapoints are sent to SignalFx:
136
+
137
+ | Metric Name | Type | Description |
138
+ | --- | --- | --- |
139
+ | `function.invocations` | Counter | Count number of Lambda invocations |
140
+ | `function.cold_starts` | Counter | Count number of cold starts |
141
+ | `function.errors` | Counter | Count number of errors captured from underlying Lambda handler |
142
+ | `function.duration` | Gauge | Execution time of the underlying Lambda handler in milliseconds |
143
+
144
+ Each datapoint has the following dimensions:
145
+ - `metric_source`: `ruby-lambda-wrapper`
146
+ - `lambda_arn`: the full ARN of the invocation
147
+ - `aws_region`: the region that the function executed in
148
+ - `aws_account_id`: id of the account this function ran for
149
+ - `aws_function_name`: the function name set for this Lambda
150
+ - `aws_function_version`: the function version
151
+ - `aws_function_qualifier`: function version qualifier, which will be a version
152
+ or version alias if it is not an event source mapping invocation
153
+ - `event_source_mappings`: function name if it is an event source mapping invocation
154
+ - `aws_execution_env`: the name of the runtime environment running this function
155
+ - `function_wrapper_version`: the version of this wrapper gem being used
156
+ - `log_group_name`: log group for the function
157
+ - `log_stream_name`: log stream for the instance
158
+
159
+ ## Manual Instrumentation
160
+
161
+ ### Tracing
86
162
 
87
163
  Manual tracing may be useful to get a better view into the function. The
88
164
  OpenTracing global tracer makes the tracer used by the wrapper available
89
- to when more specific instrumentation is desired.
165
+ when more specific instrumentation is desired.
90
166
 
91
167
  ```ruby
92
168
  require 'opentracing'
@@ -103,6 +179,15 @@ Lambda handler as the parent.
103
179
 
104
180
  For more examples of usage, please see [opentracing-ruby](https://github.com/opentracing/opentracing-ruby).
105
181
 
182
+ ### Metrics
183
+
184
+ Your function can be manually instrumented to send additional metrics using the
185
+ already configured SignalFx client.
186
+
187
+ ```ruby
188
+ SignalFx::Lambda::Metrics.client.send(counters: ..., gauges: ..., cumulative_counters: ...)
189
+ ```
190
+
106
191
  ## Development
107
192
 
108
193
  After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -115,4 +200,4 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/signal
115
200
 
116
201
  ## License
117
202
 
118
- The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
203
+ The gem is available as open source under the terms of the [Apache 2.0 License](https://opensource.org/licenses/Apache-2.0).
@@ -0,0 +1,88 @@
1
+ require 'signalfx'
2
+
3
+ module SignalFx
4
+ module Lambda
5
+ module Metrics
6
+ class Error < StandardError; end
7
+
8
+ class << self
9
+ attr_accessor :client
10
+
11
+ def wrap_function(event:, context:)
12
+ cold_start = @client.nil?
13
+ init_client unless @client
14
+ counters = []
15
+ gauges = []
16
+
17
+ dimensions = populate_dimensions(context)
18
+
19
+ # time execution of next block
20
+ start_time = Time.now
21
+ response = yield event: event, context: context
22
+ end_time = Time.now
23
+
24
+ duration = ((end_time - start_time) * 1000) # duration in ms
25
+ end_time = end_time.strftime('%s%L')
26
+
27
+ counters.push(
28
+ {
29
+ :metric => 'function.invocations',
30
+ :value => 1,
31
+ :timestamp => end_time,
32
+ :dimensions => dimensions
33
+ }
34
+ )
35
+
36
+ counters.push(
37
+ {
38
+ :metric => 'function.cold_starts',
39
+ :value => 1,
40
+ :timestamp => end_time,
41
+ :dimensions => dimensions
42
+ }
43
+ ) if cold_start
44
+
45
+ gauges = [
46
+ {
47
+ :metric => 'function.duration',
48
+ :value => duration,
49
+ :timestamp => end_time,
50
+ :dimensions => dimensions
51
+ }
52
+ ]
53
+
54
+ response
55
+ rescue => error
56
+ error_counter = {
57
+ :metric => 'function.errors',
58
+ :value => 1,
59
+ :timestamp => end_time,
60
+ :dimensions => dimensions
61
+ }
62
+
63
+ counters.push(error_counter)
64
+
65
+ raise
66
+ ensure
67
+ # send metrics before leaving this block
68
+ @client.send(gauges: gauges, counters: counters) if @client
69
+ end
70
+
71
+ def populate_dimensions(context)
72
+ dimensions = SignalFx::Lambda.fields.map do |key, val|
73
+ { :key => key, :value => val }
74
+ end
75
+ dimensions.merge!({ :key => 'metric_source', :value => SignalFx::Lambda::COMPONENT })
76
+ end
77
+
78
+ def init_client
79
+ access_token = ENV['SIGNALFX_ACCESS_TOKEN']
80
+ ingest_endpoint = ENV['SIGNALFX_METRICS_URL'] || ENV['SIGNALFX_ENDPOINT_URL'] || 'https://ingest.signalfx.com'
81
+
82
+ @client = SignalFx.new access_token, ingest_endpoint: ingest_endpoint
83
+ end
84
+ end
85
+ end
86
+ end
87
+ end
88
+
@@ -8,103 +8,75 @@ module SignalFx
8
8
  module Tracing
9
9
  class Error < StandardError; end
10
10
 
11
- def self.wrap_function(event, context, &block)
12
- init_tracer(event) if !@tracer # avoid initializing except on a cold start
11
+ class << self
12
+ attr_accessor :tracer, :reporter
13
13
 
14
- scope = OpenTracing.start_active_span("#{@span_prefix}#{context.function_name}", tags: build_tags(context))
14
+ def wrap_function(event:, context:, &block)
15
+ init_tracer(event) if !@tracer # avoid initializing except on a cold start
15
16
 
16
- response = yield event: event, context: context
17
- scope.span.set_tag("http.status_code", response[:statusCode]) if response[:statusCode]
17
+ tags = SignalFx::Lambda.fields
18
+ tags['component'] = SignalFx::Lambda::COMPONENT
18
19
 
19
- response
20
- rescue => error
21
- if scope
22
- scope.span.set_tag("error", true)
23
- scope.span.log_kv(key: "message", value: error.message)
24
- end
25
-
26
- # pass this error up
27
- raise
28
- ensure
29
- scope.close if scope
30
-
31
- # flush the spans before leaving the execution context
32
- @reporter.flush
33
- end
20
+ scope = OpenTracing.start_active_span("#{@span_prefix}#{context.function_name}",
21
+ tags: tags)
34
22
 
35
- def self.wrapped_handler(event:, context:)
36
- wrap_function(event, context, &@handler)
37
- end
38
-
39
- def self.build_tags(context)
40
- tags = {
41
- 'component' => 'ruby-lambda-wrapper',
42
- 'lambda_arn' => context.invoked_function_arn,
43
- 'aws_request_id' => context.aws_request_id,
44
- 'aws_function_name' => context.function_name,
45
- 'aws_function_version' => context.function_version,
46
- 'aws_execution_env' => ENV['AWS_EXECUTION_ENV'],
47
- 'log_group_name' => context.log_group_name,
48
- 'log_stream_name' => context.log_stream_name,
49
- 'function_wrapper_version' => "signalfx-lambda-#{SignalFx::Lambda::VERSION}",
50
- }
51
-
52
- tags = tags.merge(tags_from_arn(context.invoked_function_arn))
53
- end
23
+ response = yield event: event, context: context
24
+ scope.span.set_tag("http.status_code", response[:statusCode]) if response[:statusCode]
54
25
 
55
- def self.tags_from_arn(arn)
56
- _, _, _, region, account_id, resource_type, _, qualifier = arn.split(':')
26
+ response
27
+ rescue => error
28
+ if scope
29
+ scope.span.set_tag("error", true)
30
+ scope.span.log_kv(key: "message", value: error.message)
31
+ end
57
32
 
58
- tags = {
59
- 'aws_region' => region,
60
- 'aws_account_id' => account_id,
61
- }
33
+ # pass this error up
34
+ raise
35
+ ensure
36
+ scope.close if scope
62
37
 
63
- if qualifier
64
- case resource_type
65
- when 'function'
66
- tags['aws_function_qualifier'] = qualifier
67
- when 'event-source-mappings'
68
- tags['event_source_mappings'] = qualifier
69
- end
38
+ # flush the spans before leaving the execution context
39
+ @reporter.flush
70
40
  end
71
41
 
72
- tags
73
- end
42
+ def wrapped_handler(event:, context:)
43
+ wrap_function(event, context, &@handler)
44
+ end
74
45
 
75
- def self.register_handler(&handler)
76
- @handler = handler
77
- end
46
+ def register_handler(&handler)
47
+ @handler = handler
48
+ end
78
49
 
79
- def self.init_tracer(event)
80
- access_token = ENV['SIGNALFX_ACCESS_TOKEN']
81
- ingest_url = ENV['SIGNALFX_INGEST_URL'] || 'https://ingest.signalfx.com/v1/trace'
82
- service_name = ENV['SIGNALFX_SERVICE_NAME'] || event.function_name
83
- @span_prefix = ENV['SIGNALFX_SPAN_PREFIX'] || 'lambda_ruby_'
84
-
85
- # configure the trace reporter
86
- headers = { }
87
- headers['X-SF-Token'] = access_token if !access_token.empty?
88
- encoder = Jaeger::Client::Encoders::ThriftEncoder.new(service_name: service_name)
89
- sender = Jaeger::Client::HttpSender.new(url: ingest_url, headers: headers, encoder: encoder, logger: Logger.new(STDOUT))
90
- @reporter = Jaeger::Client::Reporters::RemoteReporter.new(sender: sender, flush_interval: 1)
91
-
92
- # propagation format configuration
93
- injectors = {
94
- OpenTracing::FORMAT_TEXT_MAP => [Jaeger::Client::Injectors::B3RackCodec]
95
- }
96
- extractors = {
97
- OpenTracing::FORMAT_TEXT_MAP => [SignalFx::Lambda::Tracing::B3TextMapCodec]
98
- }
99
-
100
- OpenTracing.global_tracer = Jaeger::Client.build(
101
- service_name: service_name,
102
- reporter: @reporter,
103
- injectors: injectors,
104
- extractors: extractors
105
- )
106
-
107
- @tracer = OpenTracing.global_tracer
50
+ def init_tracer(event)
51
+ access_token = ENV['SIGNALFX_ACCESS_TOKEN']
52
+ ingest_url = ENV['SIGNALFX_TRACING_URL'] || ENV['SIGNALFX_ENDPOINT_URL'] || 'https://ingest.signalfx.com/v1/trace'
53
+ service_name = ENV['SIGNALFX_SERVICE_NAME'] || event.function_name
54
+ @span_prefix = ENV['SIGNALFX_SPAN_PREFIX'] || 'lambda_ruby_'
55
+
56
+ # configure the trace reporter
57
+ headers = { }
58
+ headers['X-SF-Token'] = access_token if !access_token.empty?
59
+ encoder = Jaeger::Client::Encoders::ThriftEncoder.new(service_name: service_name)
60
+ sender = Jaeger::Client::HttpSender.new(url: ingest_url, headers: headers, encoder: encoder, logger: Logger.new(STDOUT))
61
+ @reporter = Jaeger::Client::Reporters::RemoteReporter.new(sender: sender, flush_interval: 100)
62
+
63
+ # propagation format configuration
64
+ injectors = {
65
+ OpenTracing::FORMAT_TEXT_MAP => [Jaeger::Client::Injectors::B3RackCodec]
66
+ }
67
+ extractors = {
68
+ OpenTracing::FORMAT_TEXT_MAP => [SignalFx::Lambda::Tracing::B3TextMapCodec]
69
+ }
70
+
71
+ OpenTracing.global_tracer = Jaeger::Client.build(
72
+ service_name: service_name,
73
+ reporter: @reporter,
74
+ injectors: injectors,
75
+ extractors: extractors
76
+ )
77
+
78
+ @tracer = OpenTracing.global_tracer
79
+ end
108
80
  end
109
81
  end
110
82
  end
@@ -1,5 +1,5 @@
1
1
  module SignalFx
2
2
  module Lambda
3
- VERSION = "0.1.0"
3
+ VERSION = "0.2.0"
4
4
  end
5
5
  end
@@ -1,2 +1,81 @@
1
1
  require 'signalfx/lambda/version'
2
2
  require 'signalfx/lambda/tracing'
3
+ require 'signalfx/lambda/metrics'
4
+
5
+ module SignalFx
6
+ module Lambda
7
+ class Error < StandardError; end
8
+
9
+ COMPONENT = 'ruby-lambda-wrapper'.freeze
10
+
11
+ class << self
12
+ attr_accessor :fields
13
+
14
+ def wrapped_handler(event:, context:)
15
+ # gather some useful information from the execution context and ARN and
16
+ # make it available to the handlers
17
+ @fields = gather_fields(context)
18
+ @wrapped_handler.call(event: event, context: context)
19
+ end
20
+
21
+ def register_handler(metrics: true, tracing: true, &handler)
22
+ @handler = handler # the original handler
23
+
24
+ # Add the wrappers needed
25
+ wrappers = []
26
+ wrappers.push(@handler)
27
+ wrappers.push(Tracing.method(:wrap_function)) if tracing
28
+ wrappers.push(Metrics.method(:wrap_function)) if metrics
29
+
30
+ @wrapped_handler = build_wrapped_handler(wrappers) if @wrapped_handler.nil?
31
+ end
32
+
33
+ # build a nested block depending on the wrappers enabled
34
+ def build_wrapped_handler(wrappers)
35
+ wrappers.inject do |inner, outer|
36
+ proc do |event:, context:|
37
+ outer.call(event: event, context: context, &inner)
38
+ end
39
+ end
40
+ end
41
+
42
+ # build a map of useful properties from the context object
43
+ def gather_fields(context)
44
+ fields = {
45
+ 'lambda_arn' => context.invoked_function_arn,
46
+ 'aws_request_id' => context.aws_request_id,
47
+ 'aws_function_name' => context.function_name,
48
+ 'aws_function_version' => context.function_version,
49
+ 'aws_execution_env' => ENV['AWS_EXECUTION_ENV'],
50
+ 'log_group_name' => context.log_group_name,
51
+ 'log_stream_name' => context.log_stream_name,
52
+ 'function_wrapper_version' => "signalfx-lambda-#{SignalFx::Lambda::VERSION}",
53
+ }
54
+
55
+ fields.merge!(fields_from_arn(context.invoked_function_arn))
56
+ end
57
+
58
+ # the arn packs useful data, including region, account id, resource type,
59
+ # and qualifier
60
+ def fields_from_arn(arn = '')
61
+ _, _, _, region, account_id, resource_type, _, qualifier = arn.split(':')
62
+
63
+ fields = {
64
+ 'aws_region' => region,
65
+ 'aws_account_id' => account_id,
66
+ }
67
+
68
+ if qualifier
69
+ case resource_type
70
+ when 'function'
71
+ fields['aws_function_qualifier'] = qualifier
72
+ when 'event-source-mappings'
73
+ fields['event_source_mappings'] = qualifier
74
+ end
75
+ end
76
+
77
+ fields
78
+ end
79
+ end
80
+ end
81
+ end
@@ -24,6 +24,7 @@ Gem::Specification.new do |spec|
24
24
 
25
25
  spec.add_dependency "jaeger-client", "~> 0.10.0"
26
26
  spec.add_dependency "opentracing", "~> 0.3"
27
- spec.add_development_dependency "bundler", "~> 1.17"
27
+ spec.add_dependency "signalfx"
28
+ spec.add_development_dependency "bundler", "~> 2.0"
28
29
  spec.add_development_dependency "rake", "~> 10.0"
29
30
  end
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: signalfx-lambda
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.1.0
4
+ version: 0.2.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Ashwin Chandrasekar
8
8
  autorequire:
9
9
  bindir: exe
10
10
  cert_chain: []
11
- date: 2019-01-11 00:00:00.000000000 Z
11
+ date: 2019-02-21 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: jaeger-client
@@ -38,20 +38,34 @@ dependencies:
38
38
  - - "~>"
39
39
  - !ruby/object:Gem::Version
40
40
  version: '0.3'
41
+ - !ruby/object:Gem::Dependency
42
+ name: signalfx
43
+ requirement: !ruby/object:Gem::Requirement
44
+ requirements:
45
+ - - ">="
46
+ - !ruby/object:Gem::Version
47
+ version: '0'
48
+ type: :runtime
49
+ prerelease: false
50
+ version_requirements: !ruby/object:Gem::Requirement
51
+ requirements:
52
+ - - ">="
53
+ - !ruby/object:Gem::Version
54
+ version: '0'
41
55
  - !ruby/object:Gem::Dependency
42
56
  name: bundler
43
57
  requirement: !ruby/object:Gem::Requirement
44
58
  requirements:
45
59
  - - "~>"
46
60
  - !ruby/object:Gem::Version
47
- version: '1.17'
61
+ version: '2.0'
48
62
  type: :development
49
63
  prerelease: false
50
64
  version_requirements: !ruby/object:Gem::Requirement
51
65
  requirements:
52
66
  - - "~>"
53
67
  - !ruby/object:Gem::Version
54
- version: '1.17'
68
+ version: '2.0'
55
69
  - !ruby/object:Gem::Dependency
56
70
  name: rake
57
71
  requirement: !ruby/object:Gem::Requirement
@@ -81,6 +95,7 @@ files:
81
95
  - bin/console
82
96
  - bin/setup
83
97
  - lib/signalfx/lambda.rb
98
+ - lib/signalfx/lambda/metrics.rb
84
99
  - lib/signalfx/lambda/tracing.rb
85
100
  - lib/signalfx/lambda/tracing/extractors.rb
86
101
  - lib/signalfx/lambda/version.rb
@@ -104,8 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
104
119
  - !ruby/object:Gem::Version
105
120
  version: '0'
106
121
  requirements: []
107
- rubyforge_project:
108
- rubygems_version: 2.7.3
122
+ rubygems_version: 3.0.2
109
123
  signing_key:
110
124
  specification_version: 4
111
125
  summary: Lambda handler wrapper