OpenTelemetry is an open source observability framework, providing a general-purpose API, SDK, and related tools required for the instrumentation of cloud-native software, frameworks, and libraries.
+
+
The OpenTelemetry module provides global accessors for telemetry objects. See the documentation for the opentelemetry-api gem for details.
ConfigurationError is an exception type used to wrap configuration errors passed to OpenTelemetry.error_handler. This can be used to distinguish errors reported during SDK configuration.
Accepts a logger and wraps it in the ForwardingLogger which allows for controlling the severity level emitted by the OpenTelemetry.logger independently of the supplied logger.
A span_processor that satisfies the duck type #on_start, #on_finish, #shutdown, #force_flush. See SimpleSpanProcessor for an example.
+
+
+
+
+
+
+
+
+
+
+
+
+
+125
+126
+127
+
+
+
# File 'lib/opentelemetry/sdk/configurator.rb', line 125
+
+defadd_span_processor(span_processor)
+ @span_processors<<span_processor
+end
+
+
+
+
+
+
+
+
+ #configure ⇒ Object
+
+
+
+
+
+
+
+
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
+
The configure method is where we define the setup process. This allows us to make certain guarantees about which systems and globals are setup at each stage. The setup process is: - setup logging - setup propagation - setup tracer_provider and meter_provider - install instrumentation
# File 'lib/opentelemetry/sdk/configurator.rb', line 46
+
+deflogger
+ @logger||=OpenTelemetry.logger
+end
+
+
+
+
+
+
+
+
+ #logger=(new_logger) ⇒ Object
+
+
+
+
+
+
+
+
+
Accepts a logger and wraps it in the ForwardingLogger which allows for controlling the severity level emitted by the OpenTelemetry.logger independently of the supplied logger.
+
+
+
+
+
+
Parameters:
+
+
+
+
+ new_logger
+
+
+ (Logger)
+
+
+
+ —
+
+
The logger for OpenTelemetry to use
+
+
+
+
+
+
+
+
+
+
+
+
+
+55
+56
+57
+
+
+
# File 'lib/opentelemetry/sdk/configurator.rb', line 55
+
+deflogger=(new_logger)
+ @logger=ForwardingLogger.new(new_logger,level:ENV['OTEL_LOG_LEVEL']||Logger::INFO)
+end
+
+
+
+
+
+
+
+
+ #resource=(new_resource) ⇒ Object
+
+
+
+
+
+
+
+
+
Accepts a resource object that is merged with the default telemetry sdk resource. The use of this method is optional, and is provided as means to include additional resource information. If a resource key collision occurs the passed in resource takes priority.
+
+
+
+
+
+
Parameters:
+
+
+
+
+ new_resource
+
+
+ (Resource)
+
+
+
+ —
+
+
The resource to be merged
+
+
+
+
+
+
+
+
+
+
+
+
+
+69
+70
+71
+
+
+
# File 'lib/opentelemetry/sdk/configurator.rb', line 69
+
+defresource=(new_resource)
+ @resource=@resource.merge(new_resource)
+end
Accepts a string that is merged in as the service.name resource attribute. The most recent assigned value will be used in the event of repeated calls to this setter.
Accepts a string that is merged in as the service.version resource attribute. The most recent assigned value will be used in the event of repeated calls to this setter.
Install an instrumentation with specificied optional config. Use can be called multiple times to install multiple instrumentation. Only use or use_all, but not both when installing instrumentation. A call to use_all after use will result in an exception.
Install all registered instrumentation. Configuration for specific instrumentation can be provided with the optional instrumentation_config_map parameter. Only use or use_all, but not both when installing instrumentation. A call to use after use_all will result in an exception.
The ForwardingLogger provides a wrapper to control the OpenTelemetry log level, while respecting the configured level of the supplied logger. If the OTEL_LOG_LEVEL is set to debug, and the supplied logger is configured with an ERROR log level, only OpenTelemetry logs at the ERROR level or higher will be emitted.
+
+ Hash{String
+
+
+ (Hash{String => String, Numeric, Boolean} attributes Hash of key-value pairs to be used
+as attributes for this resource)
+
+
+
+ —
+
+
=> String, Numeric, Boolean} attributes Hash of key-value pairs to be used as attributes for this resource
Implementation of the duck type SpanProcessor that batches spans exported by the SDK then pushes them to the exporter pipeline.
+
+
Typically, the BatchSpanProcessor will be more suitable for production environments than the SimpleSpanProcessor.
+
+
All spans reported by the SDK implementation are first added to a synchronized queue (with a #max_queue_size maximum size, after the size is reached spans are dropped) and exported every schedule_delay to the exporter pipeline in batches of max_export_batch_size.
+
+
If the queue gets half full a preemptive notification is sent to the worker thread that exports the spans to wake up and start a new export cycle.
the delay interval between two consecutive exports. Defaults to the value of the OTEL_BSP_SCHEDULE_DELAY environment variable, if set, or 5,000 (5 seconds).
Export all ended spans to the configured Exporter that have not yet been exported.
+
+
This method should only be called in cases where it is absolutely necessary, such as when using some FaaS providers that may suspend the process after an invocation, but before the Processor exports the completed spans.
# File 'lib/opentelemetry/sdk/trace/export/batch_span_processor.rb', line 103
+
+defforce_flush(timeout:nil)# rubocop:disable Metrics/MethodLength
+start_time=OpenTelemetry::Common::Utilities.timeout_timestamp
+ snapshot=lockdo
+ reset_on_fork(restart_thread:@keep_running)
+ spans.shift(spans.size)
+ end
+ untilsnapshot.empty?
+ remaining_timeout=OpenTelemetry::Common::Utilities.maybe_timeout(timeout,start_time)
+ returnTIMEOUTifremaining_timeout&.zero?
+
+ batch=snapshot.shift(@batch_size)
+ result_code=export_batch(batch,timeout:remaining_timeout)
+ returnresult_codeunlessresult_code==SUCCESS
+ end
+
+ @exporter.force_flush(timeout:OpenTelemetry::Common::Utilities.maybe_timeout(timeout,start_time))
+ensure
+ # Unshift the remaining spans if we timed out. We drop excess spans from
+# the snapshot because they're older than any spans in the spans buffer.
+lockdo
+ n=spans.size+snapshot.size-max_queue_size
+ ifn.positive?
+ dropped_spans=snapshot.shift(n)
+ report_dropped_spans(dropped_spans,reason:'buffer-full',function:__method__.to_s)
+ end
+ spans.unshift(*snapshot)unlesssnapshot.empty?
+ @condition.signalifspans.size>max_queue_size/2
+ end
+end
+
+
+
+
+
+
+
+
+ #on_finish(span) ⇒ Object
+
+
+
+
+
+
+
+
+
Adds a span to the batch. Thread-safe; may block on lock.
Returns a frozen array of the finished SpanDatas, represented by ioio.opentelemetryio.opentelemetry.protoio.opentelemetry.proto.traceio.opentelemetry.proto.trace.v1io.opentelemetry.proto.trace.v1.Span.
Returns a frozen array of the finished SpanDatas, represented by OpenTelemetry::SDK::Trace::Export::InMemorySpanExporter.ioio.opentelemetryio.opentelemetry.protoio.opentelemetry.proto.traceio.opentelemetry.proto.trace.v1io.opentelemetry.proto.trace.v1.Span.
MetricsReporter defines an interface used for reporting metrics from span processors (like the BatchSpanProcessor) and exporters. It can be used to report metrics such as dropped spans, and successful and failed export attempts. This exists to decouple the Trace SDK from the unstable OpenTelemetry Metrics API. An example implementation in terms of StatsD is:
+
+
+
+
+
+
+
+
Examples:
+
+
+
moduleMetricsReporter
+ defadd_to_counter(metric,increment:1,labels:{})
+ StatsD.increment(metric,increment,labels,no_prefix:true)
+ end
+ defrecord_value(metric,value:,labels:{})
+ StatsD.distribution(metric,value,labels,no_prefix:true)
+ end
+ defobserve_value(metric,value:,labels:{})
+ StatsD.gauge(metric,value,labels,no_prefix:true)
+ end
+end
An implementation of the duck type SpanProcessor that converts the Span to ioio.opentelemetryio.opentelemetry.protoio.opentelemetry.proto.traceio.opentelemetry.proto.trace.v1io.opentelemetry.proto.trace.v1.Span and passes it to the configured exporter.
+
+
Typically, the SimpleSpanProcessor will be most suitable for use in testing; it should be used with caution in production. It may be appropriate for production use in scenarios where creating multiple threads is not desirable as well as scenarios where different custom attributes should be added to individual spans based on code scopes.
+
+
Only spans that are recorded are converted, Trace::Span#is_recording? must return true.
the (duck type) SpanExporter to where the recorded Spans are pushed.
+
+
+
+
+
+
+
Raises:
+
+
+
+
+
+
+
+
+
+
+
+
ArgumentError if the span_exporter is nil.
+
+
+
+
+
+
+
+
+
+
+
+
+31
+32
+33
+34
+35
+
+
+
# File 'lib/opentelemetry/sdk/trace/export/simple_span_processor.rb', line 31
+
+definitialize(span_exporter)
+ raiseArgumentError,"exporter #{span_exporter.inspect} does not appear to be a valid exporter"unlessCommon::Utilities.valid_exporter?(span_exporter)
+
+ @span_exporter=span_exporter
+end
Export all ended spans to the configured Exporter that have not yet been exported, then call Exporter#force_flush.
+
+
This method should only be called in cases where it is absolutely necessary, such as when using some FaaS providers that may suspend the process after an invocation, but before the Processor exports the completed spans.
SpanExporter describes a duck type. It is not required to subclass this class to provide an implementation of SpanExporter, provided the interface is satisfied. SpanExporter allows different tracing services to export recorded data for sampled spans in their own format.
Returns a new sampler. The ratio describes the proportion of the trace ID space that is sampled.
+
+
+
+
+
+
Parameters:
+
+
+
+
+ ratio
+
+
+ (Numeric)
+
+
+
+ —
+
+
The desired sampling ratio. Must be within [0.0, 1.0].
+
+
+
+
+
+
+
Raises:
+
+
+
+
+
+ (ArgumentError)
+
+
+
+ —
+
+
if ratio is out of range
+
+
+
+
+
+
+
+
+
+
+
+
+83
+84
+85
+86
+87
+
+
+
# File 'lib/opentelemetry/sdk/trace/samplers.rb', line 83
+
+defself.trace_id_ratio_based(ratio)
+ raiseArgumentError,'ratio must be in range [0.0, 1.0]'unless(0.0..1.0).include?(ratio)
+
+ TraceIdRatioBased.new(ratio)
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/opentelemetry-sdk/v1.4.1/OpenTelemetry/SDK/Trace/Samplers/ConstantSampler.html b/opentelemetry-sdk/v1.4.1/OpenTelemetry/SDK/Trace/Samplers/ConstantSampler.html
new file mode 100644
index 0000000000..2118f4ebaf
--- /dev/null
+++ b/opentelemetry-sdk/v1.4.1/OpenTelemetry/SDK/Trace/Samplers/ConstantSampler.html
@@ -0,0 +1,459 @@
+
+
+
+
+
+
+ Class: OpenTelemetry::SDK::Trace::Samplers::ConstantSampler
+
+ — OpenTelemetry
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This class is part of a private API.
+ You should avoid using this class if possible, as it may be removed or be changed in the future.
+
+
+
This is a composite sampler. ParentBased helps distinguished between the following cases: * No parent (root span). * Remote parent (SpanContext.remote? with trace_flags.sampled?) * Remote parent (SpanContext.remote? with !trace_flags.sampled?) * Local parent (!SpanContext.remote? with trace_flags.sampled?) * Local parent (!SpanContext.remote? with !trace_flags.sampled?)
The Result class represents an arbitrary sampling result. It has boolean values for the sampling decision and whether to record events, and a collection of attributes to be attached to a sampled root span.
A frozen or freezable hash containing attributes to be attached to the span.
+
+
+
+
+
+
+ tracestate
+
+
+ (Tracestate)
+
+
+
+ —
+
+
A Tracestate that will be associated with the Span through the new SpanContext. If the sampler returns an empty Tracestate here, the Tracestate will be cleared, so samplers SHOULD normally return the passed-in Tracestate if they do not intend to change it.
Implementation of Trace::Span that records trace events.
+
+
This implementation includes reader methods intended to allow access to internal state by SpanProcessors. Instrumentation should use the API provided by Trace::Span and should consider Span to be write-only.
# File 'lib/opentelemetry/sdk/trace/span.rb', line 285
+
+definitialize(context,parent_context,parent_span,name,kind,parent_span_id,span_limits,span_processors,attributes,links,start_timestamp,resource,instrumentation_scope)# rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity
+super(span_context:context)
+ @mutex=Mutex.new
+ @name=name
+ @kind=kind
+ @parent_span_id=parent_span_id.freeze||OpenTelemetry::Trace::INVALID_SPAN_ID
+ @span_limits=span_limits
+ @span_processors=span_processors
+ @resource=resource
+ @instrumentation_scope=instrumentation_scope
+ @ended=false
+ @status=DEFAULT_STATUS
+ @total_recorded_events=0
+ @total_recorded_links=links&.size||0
+ @total_recorded_attributes=attributes&.size||0
+ @attributes=attributes
+ trim_span_attributes(@attributes)
+ @events=nil
+ @links=trim_links(links,span_limits.link_count_limit,span_limits.link_attribute_count_limit)
+
+ # Times are hard. Whenever an explicit timestamp is provided
+# (for Events or for the Span start_timestamp or end_timestamp),
+# we use that as the recorded timestamp. An implicit Event timestamp
+# and end_timestamp is computed as a monotonic clock offset from
+# the realtime start_timestamp. The realtime start_timestamp is
+# computed as a monotonic clock offset from the realtime
+# start_timestamp of its parent span, if available, or it is
+# fetched from the realtime system clock.
+#
+# We therefore have 3 start timestamps. The first two are used
+# internally (and by child spans) to compute other timestamps.
+# The last is the start timestamp actually recorded in the
+# SpanData.
+@monotonic_start_timestamp=monotonic_now
+ @realtime_start_timestamp=ifparent_span.recording?
+ relative_realtime(parent_span.realtime_start_timestamp,parent_span.monotonic_start_timestamp,@monotonic_start_timestamp)
+ else
+ realtime_now
+ end
+ @start_timestamp=ifstart_timestamp
+ time_in_nanoseconds(start_timestamp)
+ else
+ @realtime_start_timestamp
+ end
+ @end_timestamp=nil
+ @span_processors.each{|processor|processor.on_start(self,parent_context)}
+end
+
+
+
+
+
+
+
+
+
Instance Attribute Details
+
+
+
+
+
+
+ #end_timestamp ⇒ Object(readonly)
+
+
+
+
+
+
+
+
+
The following readers are intended for the use of SpanProcessors and should not be considered part of the public interface for instrumentation.
+
+
+
+
+
+
+
+
+
+
+
+
+
+26
+27
+28
+
+
+
# File 'lib/opentelemetry/sdk/trace/span.rb', line 26
+
+defend_timestamp
+ @end_timestamp
+end
+
+
+
+
+
+
+
+
+
+
+ #instrumentation_scope ⇒ Object(readonly)
+
+
+
+ Also known as:
+ instrumentation_library
+
+
+
+
+
+
+
+
The following readers are intended for the use of SpanProcessors and should not be considered part of the public interface for instrumentation.
+
+
+
+
+
+
+
+
+
+
+
+
+
+26
+27
+28
+
+
+
# File 'lib/opentelemetry/sdk/trace/span.rb', line 26
+
+definstrumentation_scope
+ @instrumentation_scope
+end
+
+
+
+
+
+
+
+
+
+
+ #kind ⇒ Object(readonly)
+
+
+
+
+
+
+
+
+
The following readers are intended for the use of SpanProcessors and should not be considered part of the public interface for instrumentation.
+
+
+
+
+
+
+
+
+
+
+
+
+
+26
+27
+28
+
+
+
# File 'lib/opentelemetry/sdk/trace/span.rb', line 26
+
+defkind
+ @kind
+end
+
+
+
+
+
+
+
+
+
+
+ #links ⇒ Object(readonly)
+
+
+
+
+
+
+
+
+
The following readers are intended for the use of SpanProcessors and should not be considered part of the public interface for instrumentation.
+
+
+
+
+
+
+
+
+
+
+
+
+
+26
+27
+28
+
+
+
# File 'lib/opentelemetry/sdk/trace/span.rb', line 26
+
+deflinks
+ @links
+end
+
+
+
+
+
+
+
+
+
+
+ #name ⇒ Object
+
+
+
+
+
+
+
+
+
The following readers are intended for the use of SpanProcessors and should not be considered part of the public interface for instrumentation.
+
+
+
+
+
+
+
+
+
+
+
+
+
+26
+27
+28
+
+
+
# File 'lib/opentelemetry/sdk/trace/span.rb', line 26
+
+defname
+ @name
+end
Values must be non-nil and (array of) string, boolean or numeric type. Array values must not contain nil elements and all elements must be of the same basic type (string, numeric, boolean).
Return a frozen copy of the current attributes. This is intended for use of SpanProcessors and should not be considered part of the public interface for instrumentation.
# File 'lib/opentelemetry/sdk/trace/span.rb', line 39
+
+defattributes
+ # Don't bother synchronizing. Access by SpanProcessors is expected to
+# be serialized.
+@attributes&.clone.freeze
+end
Return a frozen copy of the current events. This is intended for use of SpanProcessors and should not be considered part of the public interface for instrumentation.
# File 'lib/opentelemetry/sdk/trace/span.rb', line 50
+
+defevents
+ # Don't bother synchronizing. Access by SpanProcessors is expected to
+# be serialized.
+@events&.clone.freeze
+end
Implementations MUST ignore all subsequent calls to #finish (there might be exceptions when Tracer is streaming event and has no mutable state associated with the Span).
+
+
Call to #finish MUST not have any effects on child spans. Those may still be running and can be ended later.
+
+
This API MUST be non-blocking*.
+
+
(*) not actually non-blocking. In particular, it synchronizes on an internal mutex, which will typically be uncontended, and Export::BatchSpanProcessor will also synchronize on a mutex, if that processor is used.
Values must be non-nil and (array of) string, boolean or numeric type. Array values must not contain nil elements and all elements must be of the same basic type (string, numeric, boolean).
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
+
Returns a SpanData containing a snapshot of the Span fields. It is assumed that the Span has been finished, and that no further modifications will be made to the Span.
+
+
This method should be called only from a SpanProcessor prior to calling the SpanExporter.
# File 'lib/opentelemetry/sdk/trace/span_limits.rb', line 37
+
+definitialize(attribute_count_limit:Integer(OpenTelemetry::Common::Utilities.config_opt('OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT','OTEL_ATTRIBUTE_COUNT_LIMIT',default:128)),# rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+attribute_length_limit:OpenTelemetry::Common::Utilities.config_opt('OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT','OTEL_RUBY_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT','OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT'),
+ event_count_limit:Integer(OpenTelemetry::Common::Utilities.config_opt('OTEL_SPAN_EVENT_COUNT_LIMIT',default:128)),
+ link_count_limit:Integer(OpenTelemetry::Common::Utilities.config_opt('OTEL_SPAN_LINK_COUNT_LIMIT',default:128)),
+ event_attribute_count_limit:Integer(OpenTelemetry::Common::Utilities.config_opt('OTEL_EVENT_ATTRIBUTE_COUNT_LIMIT',default:128)),
+ event_attribute_length_limit:OpenTelemetry::Common::Utilities.config_opt('OTEL_EVENT_ATTRIBUTE_VALUE_LENGTH_LIMIT','OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT'),
+ link_attribute_count_limit:Integer(OpenTelemetry::Common::Utilities.config_opt('OTEL_LINK_ATTRIBUTE_COUNT_LIMIT',default:128)))
+
+ raiseArgumentError,'attribute_count_limit must be positive'unlessattribute_count_limit.positive?
+ raiseArgumentError,'attribute_length_limit must not be less than 32'unlessattribute_length_limit.nil?||Integer(attribute_length_limit)>=32
+ raiseArgumentError,'event_count_limit must be positive'unlessevent_count_limit.positive?
+ raiseArgumentError,'link_count_limit must be positive'unlesslink_count_limit.positive?
+ raiseArgumentError,'event_attribute_count_limit must be positive'unlessevent_attribute_count_limit.positive?
+ raiseArgumentError,'event_attribute_length_limit must not be less than 32'unlessevent_attribute_length_limit.nil?||Integer(event_attribute_length_limit)>=32
+ raiseArgumentError,'link_attribute_count_limit must be positive'unlesslink_attribute_count_limit.positive?
+
+ @attribute_count_limit=attribute_count_limit
+ @attribute_length_limit=attribute_length_limit.nil??nil:Integer(attribute_length_limit)
+ @event_count_limit=event_count_limit
+ @link_count_limit=link_count_limit
+ @event_attribute_count_limit=event_attribute_count_limit
+ @event_attribute_length_limit=event_attribute_length_limit.nil??nil:Integer(event_attribute_length_limit)
+ @link_attribute_count_limit=link_attribute_count_limit
+end
SpanProcessor describes a duck type and provides synchronous no-op hooks for when a Span is started or when a Span is ended. It is not required to subclass this class to provide an implementation of SpanProcessor, provided the interface is satisfied.
Export all ended spans to the configured Exporter that have not yet been exported.
+
+
This method should only be called in cases where it is absolutely necessary, such as when using some FaaS providers that may suspend the process after an invocation, but before the Processor exports the completed spans.
Immediately export all spans that have not yet been exported for all the registered SpanProcessors.
+
+
This method should only be called in cases where it is absolutely necessary, such as when using some FaaS providers that may suspend the process after an invocation, but before the Processor exports the completed spans.
This operation may block until all the Spans are processed. Must be called before turning off the main application to ensure all data are processed and exported.
+
+
After this is called all the newly created Spans will be no-op.
The opentelemetry-sdk gem provides the reference implementation of the OpenTelemetry Ruby API. Using opentelemetry-sdk, an application can collect, analyze, and export telemetry data such as distributed traces and metrics.
+
+
What is OpenTelemetry?
+
+
OpenTelemetry is an open source observability framework, providing a general-purpose API, SDK, and related tools required for the instrumentation of cloud-native software, frameworks, and libraries.
+
+
OpenTelemetry provides a single set of APIs, libraries, agents, and collector services to capture distributed traces and metrics from your application. You can analyze them using Prometheus, Jaeger, and other observability tools.
+
+
How does this gem fit in?
+
+
The opentelemetry-sdk gem provides the reference implementation of the OpenTelemetry Ruby interfaces defined in the opentelemetry-api gem. That is, it includes the functionality needed to collect, analyze, and export telemetry data produced using the API.
+
+
Generally, Ruby applications should install opentelemetry-sdk (or other concrete implementation of the OpenTelemetry API). Using the SDK, an application can configure how it wants telemetry data to be handled, including which data should be persisted, how it should be formatted, and where it should be recorded or exported. However, libraries that produce telemetry data should generally depend only on opentelemetry-api, deferring the choise of concrete implementation to the application developer.
+
+
How do I get started?
+
+
Install the gem using:
+
+
geminstallopentelemetry-sdk
+
+
+
Or, if you use bundler, include opentelemetry-sdk in your Gemfile.
+
+
Then, configure the SDK according to your desired handling of telemetry data, and use the OpenTelemetry interfaces to produces traces and other information. Following is a basic example.
+
+
require'opentelemetry/sdk'
+
+# Configure the sdk with default export and context propagation formats.
+OpenTelemetry::SDK.configure
+
+# Many configuration options may be set via the environment. To use them,
+# set the appropriate variable before calling configure. For example:
+#
+# ENV['OTEL_TRACES_EXPORTER'] = 'console'
+# ENV['OTEL_PROPAGATORS'] = 'ottrace'
+# OpenTelemetry::SDK.configure
+#
+# You may also configure the SDK programmatically, for advanced usage or to
+# enable auto-instrumentation. For example:
+#
+# OpenTelemetry::SDK.configure do |c|
+# c.service_name = something_calculated_dynamically
+# c.add_span_processor(
+# OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(
+# OpenTelemetry::SDK::Trace::Export::ConsoleSpanExporter.new
+# )
+# )
+#
+# c.use 'OpenTelemetry::Instrumentation::Net::HTTP'
+# end
+#
+# Note that the SimpleSpanExporter is not recommended for use in production.
+
+
+# To start a trace you need to get a Tracer from the TracerProvider
+tracer=OpenTelemetry.tracer_provider.tracer('my_app_or_gem','0.1.0')
+
+# create a span
+tracer.in_span('foo')do|span|
+ # set an attribute
+span.set_attribute('platform','osx')
+ # add an event
+span.add_event('event in bar')
+ # create bar as child of foo
+tracer.in_span('bar')do|child_span|
+ # inspect the span
+ppchild_span
+ end
+end
+
The opentelemetry-sdk gem source is on github, along with related gems including opentelemetry-api.
+
+
The OpenTelemetry Ruby gems are maintained by the OpenTelemetry-Ruby special interest group (SIG). You can get involved by joining us in GitHub Discussions or attending our weekly meeting. See the meeting calendar for dates and times. For more information on this and other language SIGs, see the OpenTelemetry community page.
+
+
License
+
+
The opentelemetry-sdk gem is distributed under the Apache 2.0 license. See LICENSE for more information.
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/opentelemetry-sdk/v1.4.1/file_list.html b/opentelemetry-sdk/v1.4.1/file_list.html
new file mode 100644
index 0000000000..18ae61872d
--- /dev/null
+++ b/opentelemetry-sdk/v1.4.1/file_list.html
@@ -0,0 +1,61 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ File List
+
+
+
+
The opentelemetry-sdk gem provides the reference implementation of the OpenTelemetry Ruby API. Using opentelemetry-sdk, an application can collect, analyze, and export telemetry data such as distributed traces and metrics.
+
+
What is OpenTelemetry?
+
+
OpenTelemetry is an open source observability framework, providing a general-purpose API, SDK, and related tools required for the instrumentation of cloud-native software, frameworks, and libraries.
+
+
OpenTelemetry provides a single set of APIs, libraries, agents, and collector services to capture distributed traces and metrics from your application. You can analyze them using Prometheus, Jaeger, and other observability tools.
+
+
How does this gem fit in?
+
+
The opentelemetry-sdk gem provides the reference implementation of the OpenTelemetry Ruby interfaces defined in the opentelemetry-api gem. That is, it includes the functionality needed to collect, analyze, and export telemetry data produced using the API.
+
+
Generally, Ruby applications should install opentelemetry-sdk (or other concrete implementation of the OpenTelemetry API). Using the SDK, an application can configure how it wants telemetry data to be handled, including which data should be persisted, how it should be formatted, and where it should be recorded or exported. However, libraries that produce telemetry data should generally depend only on opentelemetry-api, deferring the choise of concrete implementation to the application developer.
+
+
How do I get started?
+
+
Install the gem using:
+
+
geminstallopentelemetry-sdk
+
+
+
Or, if you use bundler, include opentelemetry-sdk in your Gemfile.
+
+
Then, configure the SDK according to your desired handling of telemetry data, and use the OpenTelemetry interfaces to produces traces and other information. Following is a basic example.
+
+
require'opentelemetry/sdk'
+
+# Configure the sdk with default export and context propagation formats.
+OpenTelemetry::SDK.configure
+
+# Many configuration options may be set via the environment. To use them,
+# set the appropriate variable before calling configure. For example:
+#
+# ENV['OTEL_TRACES_EXPORTER'] = 'console'
+# ENV['OTEL_PROPAGATORS'] = 'ottrace'
+# OpenTelemetry::SDK.configure
+#
+# You may also configure the SDK programmatically, for advanced usage or to
+# enable auto-instrumentation. For example:
+#
+# OpenTelemetry::SDK.configure do |c|
+# c.service_name = something_calculated_dynamically
+# c.add_span_processor(
+# OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(
+# OpenTelemetry::SDK::Trace::Export::ConsoleSpanExporter.new
+# )
+# )
+#
+# c.use 'OpenTelemetry::Instrumentation::Net::HTTP'
+# end
+#
+# Note that the SimpleSpanExporter is not recommended for use in production.
+
+
+# To start a trace you need to get a Tracer from the TracerProvider
+tracer=OpenTelemetry.tracer_provider.tracer('my_app_or_gem','0.1.0')
+
+# create a span
+tracer.in_span('foo')do|span|
+ # set an attribute
+span.set_attribute('platform','osx')
+ # add an event
+span.add_event('event in bar')
+ # create bar as child of foo
+tracer.in_span('bar')do|child_span|
+ # inspect the span
+ppchild_span
+ end
+end
+
The opentelemetry-sdk gem source is on github, along with related gems including opentelemetry-api.
+
+
The OpenTelemetry Ruby gems are maintained by the OpenTelemetry-Ruby special interest group (SIG). You can get involved by joining us in GitHub Discussions or attending our weekly meeting. See the meeting calendar for dates and times. For more information on this and other language SIGs, see the OpenTelemetry community page.
+
+
License
+
+
The opentelemetry-sdk gem is distributed under the Apache 2.0 license. See LICENSE for more information.