langfuse-rb 0.7.0 → 0.9.0

data/lib/langfuse/config.rb

@@ -18,6 +18,7 @@ module Langfuse
   #     c.secret_key = "sk_..."
   #   end
   #
+  # rubocop:disable Metrics/ClassLength
   class Config
     # @return [String, nil] Langfuse public API key
     attr_accessor :public_key
@@ -74,6 +75,12 @@ module Langfuse
     # @return [String, nil] Default release identifier applied to new traces/observations
     attr_accessor :release
 
+    # @return [Float] Trace sampling rate from 0.0 to 1.0
+    attr_reader :sample_rate
+
+    # @return [#call, nil] Callback that decides whether an ended span should export to Langfuse.
+    attr_accessor :should_export_span
+
     # @return [#call, nil] Mask callable applied to input, output, and metadata before serialization.
     #   Receives `data:` keyword argument. nil disables masking.
     attr_accessor :mask
@@ -114,6 +121,9 @@ module Langfuse
     # @return [Symbol] Default ActiveJob queue name
     DEFAULT_JOB_QUEUE = :default
 
+    # @return [Float] Default trace sampling rate (sample all traces)
+    DEFAULT_SAMPLE_RATE = 1.0
+
     # @return [Integer] Number of seconds representing indefinite cache duration (~1000 years)
     INDEFINITE_SECONDS = 1000 * 365 * 24 * 60 * 60
 
@@ -136,7 +146,6 @@ module Langfuse
     # @yield [config] Optional block for configuration
     # @yieldparam config [Config] The config instance
     # @return [Config] a new Config instance
-    # rubocop:disable Metrics/AbcSize
     def initialize
       @public_key = ENV.fetch("LANGFUSE_PUBLIC_KEY", nil)
       @secret_key = ENV.fetch("LANGFUSE_SECRET_KEY", nil)
@@ -153,14 +162,11 @@ module Langfuse
       @batch_size = DEFAULT_BATCH_SIZE
       @flush_interval = DEFAULT_FLUSH_INTERVAL
       @job_queue = DEFAULT_JOB_QUEUE
-      @environment = env_value("LANGFUSE_TRACING_ENVIRONMENT")
-      @release = env_value("LANGFUSE_RELEASE") || detect_release_from_ci_env
-      @mask = nil
+      initialize_tracing_defaults
       @logger = default_logger
 
       yield(self) if block_given?
     end
-    # rubocop:enable Metrics/AbcSize
 
     # Validate the configuration
     #
@@ -183,7 +189,8 @@ module Langfuse
       validate_swr_config!
 
       validate_cache_backend!
-
+      validate_sample_rate!
+      validate_should_export_span!
       validate_mask!
     end
     # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
@@ -205,6 +212,15 @@ module Langfuse
       cache_stale_ttl == :indefinite ? INDEFINITE_SECONDS : cache_stale_ttl
     end
 
+    # Set trace sampling rate.
+    #
+    # @param value [Numeric, String] Sampling rate from 0.0 to 1.0
+    # @raise [ConfigurationError] if value is non-numeric or outside 0.0..1.0
+    # @return [Float]
+    def sample_rate=(value)
+      @sample_rate = coerce_sample_rate(value)
+    end
+
     private
 
     def default_logger
@@ -215,6 +231,14 @@ module Langfuse
       end
     end
 
+    def initialize_tracing_defaults
+      @environment = env_value("LANGFUSE_TRACING_ENVIRONMENT")
+      @release = env_value("LANGFUSE_RELEASE") || detect_release_from_ci_env
+      self.sample_rate = env_value("LANGFUSE_SAMPLE_RATE") || DEFAULT_SAMPLE_RATE
+      @should_export_span = nil
+      @mask = nil
+    end
+
     def validate_cache_backend!
       valid_backends = %i[memory rails]
       return if valid_backends.include?(cache_backend)
@@ -255,12 +279,24 @@ module Langfuse
       raise ConfigurationError, "cache_refresh_threads must be positive"
     end
 
+    def validate_sample_rate!
+      return if sample_rate.is_a?(Numeric) && sample_rate.between?(0.0, 1.0)
+
+      raise ConfigurationError, "sample_rate must be between 0.0 and 1.0"
+    end
+
     def validate_mask!
       return if mask.nil? || mask.respond_to?(:call)
 
       raise ConfigurationError, "mask must respond to #call"
     end
 
+    def validate_should_export_span!
+      return if should_export_span.nil? || should_export_span.respond_to?(:call)
+
+      raise ConfigurationError, "should_export_span must respond to #call"
+    end
+
     def detect_release_from_ci_env
       COMMON_RELEASE_ENV_KEYS.each do |key|
         value = env_value(key)
@@ -276,5 +312,22 @@ module Langfuse
 
       value
     end
+
+    def coerce_sample_rate(value)
+      numeric_value = if value.is_a?(Numeric)
+                        value.to_f
+                      elsif value.is_a?(String)
+                        Float(value)
+                      else
+                        raise ConfigurationError, "sample_rate must be numeric"
+                      end
+
+      return numeric_value if numeric_value.between?(0.0, 1.0)
+
+      raise ConfigurationError, "sample_rate must be between 0.0 and 1.0"
+    rescue ArgumentError, TypeError
+      raise ConfigurationError, "sample_rate must be numeric"
+    end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/langfuse/otel_attributes.rb

@@ -302,11 +302,9 @@ module Langfuse
     # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     def self.add_prompt_attributes(otel_attributes, prompt)
       return unless prompt
+      return if fallback_prompt?(prompt)
 
-      # Handle hash-like prompts
       if prompt.is_a?(Hash) || prompt.respond_to?(:[])
-        return if prompt[:is_fallback] || prompt["is_fallback"]
-
         otel_attributes[OBSERVATION_PROMPT_NAME] = prompt[:name] || prompt["name"]
         otel_attributes[OBSERVATION_PROMPT_VERSION] = prompt[:version] || prompt["version"]
       # Handle objects with name/version methods (already converted in Trace#generation)
@@ -315,6 +313,16 @@ module Langfuse
         otel_attributes[OBSERVATION_PROMPT_VERSION] = prompt.version
       end
     end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+    # @api private
+    def self.fallback_prompt?(prompt)
+      return true if prompt.respond_to?(:is_fallback) && prompt.is_fallback
+      return false unless prompt.is_a?(Hash)
+
+      !!get_hash_value(prompt, :is_fallback)
+    end
+    private_class_method :fallback_prompt?
   end
-  # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/ModuleLength
+  # rubocop:enable Metrics/ModuleLength
 end

data/lib/langfuse/otel_setup.rb

@@ -2,104 +2,78 @@
 
 require "opentelemetry/sdk"
 require "opentelemetry/exporter/otlp"
-require "opentelemetry/trace/propagation/trace_context"
 require "base64"
 
 module Langfuse
-  # OpenTelemetry initialization and setup
-  #
-  # Handles configuration of the OTel SDK with Langfuse OTLP exporter
-  # when tracing is enabled.
-  #
+  # OpenTelemetry initialization and setup for Langfuse tracing.
+  # rubocop:disable Metrics/ModuleLength
   module OtelSetup
+    TRACING_CONFIG_FIELDS = %i[
+      public_key
+      secret_key
+      base_url
+      environment
+      release
+      sample_rate
+      should_export_span
+      tracing_async
+      batch_size
+      flush_interval
+    ].freeze
+    private_constant(:TRACING_CONFIG_FIELDS)
+
     class << self
-      # @return [OpenTelemetry::SDK::Trace::TracerProvider, nil] The configured tracer provider
+      # @return [OpenTelemetry::SDK::Trace::TracerProvider, nil] The configured internal tracer provider
       attr_reader :tracer_provider
 
-      # Initialize OpenTelemetry with Langfuse OTLP exporter
+      # Initialize Langfuse's internal tracer provider without mutating global OpenTelemetry state.
       #
       # @param config [Langfuse::Config] The Langfuse configuration
-      # @return [void]
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      # @return [OpenTelemetry::SDK::Trace::TracerProvider]
       def setup(config)
-        # Create OTLP exporter configured for Langfuse
-        exporter = OpenTelemetry::Exporter::OTLP::Exporter.new(
-          endpoint: "#{config.base_url}/api/public/otel/v1/traces",
-          headers: build_headers(config.public_key, config.secret_key),
-          compression: "gzip"
-        )
-
-        # Create processor based on async configuration
-        # IMPORTANT: Always use BatchSpanProcessor (even in sync mode) to ensure spans
-        # are exported together, which allows proper parent-child relationship detection
-        processor = if config.tracing_async
-                      # Async: BatchSpanProcessor batches and sends in background
-                      OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(
-                        exporter,
-                        max_queue_size: config.batch_size * 2, # Buffer more than batch_size
-                        schedule_delay: config.flush_interval * 1000, # Convert seconds to milliseconds
-                        max_export_batch_size: config.batch_size
-                      )
-                    else
-                      # Sync: BatchSpanProcessor with minimal delay (flushes on force_flush)
-                      # This collects spans from the same trace and exports them together,
-                      # which is critical for correct parent_observation_id calculation
-                      OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(
-                        exporter,
-                        max_queue_size: config.batch_size * 2,
-                        schedule_delay: 60_000, # 60 seconds (relies on explicit force_flush)
-                        max_export_batch_size: config.batch_size
-                      )
-                    end
-
-        # Create TracerProvider with processor
-        @tracer_provider = OpenTelemetry::SDK::Trace::TracerProvider.new
-        @tracer_provider.add_span_processor(processor)
-
-        # Add span processor for propagated attributes and env/release defaults
-        # This must be added AFTER the BatchSpanProcessor so it runs before export and can
-        # apply all attributes (propagated IDs, environment, release) to the spans being sent
-        span_processor = SpanProcessor.new(config: config)
-        @tracer_provider.add_span_processor(span_processor)
-
-        # Set as global tracer provider
-        OpenTelemetry.tracer_provider = @tracer_provider
-
-        # Configure W3C TraceContext propagator if not already set
-        if OpenTelemetry.propagation.is_a?(OpenTelemetry::Context::Propagation::NoopTextMapPropagator)
-          OpenTelemetry.propagation = OpenTelemetry::Trace::Propagation::TraceContext::TextMapPropagator.new
-          config.logger.debug("Langfuse: Configured W3C TraceContext propagator")
-        else
-          config.logger.debug("Langfuse: Using existing propagator: #{OpenTelemetry.propagation.class}")
+        validate_tracing_config!(config)
+        return existing_provider_for(config) if initialized?
+
+        candidate_provider = nil
+        provider = nil
+        created = false
+        candidate_provider = build_tracer_provider(config)
+        provider, created = publish_provider(candidate_provider, tracing_config_snapshot(config))
+        unless created
+          candidate_provider.shutdown(timeout: 30)
+          return existing_provider_for(config)
         end
 
-        mode = config.tracing_async ? "async" : "sync"
-        config.logger.info("Langfuse tracing initialized with OpenTelemetry (#{mode} mode)")
+        log_initialized(config)
+        provider
+      rescue StandardError
+        rollback_provider(provider) if created
+        raise
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
-      # Shutdown the tracer provider and flush any pending spans
+      # Shutdown the internal tracer provider and flush any pending spans.
       #
       # @param timeout [Integer] Timeout in seconds
       # @return [void]
       def shutdown(timeout: 30)
-        return unless @tracer_provider
-
-        @tracer_provider.shutdown(timeout: timeout)
-        @tracer_provider = nil
+        provider = nil
+        setup_mutex.synchronize do
+          provider = @tracer_provider
+          @tracer_provider = nil
+          @config_snapshot = nil
+        end
+        provider&.shutdown(timeout: timeout)
       end
 
-      # Force flush all pending spans
+      # Force flush all pending spans on the internal tracer provider.
       #
       # @param timeout [Integer] Timeout in seconds
       # @return [void]
       def force_flush(timeout: 30)
-        return unless @tracer_provider
-
-        @tracer_provider.force_flush(timeout: timeout)
+        @tracer_provider&.force_flush(timeout: timeout)
       end
 
-      # Check if OTel is initialized
+      # Check if Langfuse tracing has been initialized.
       #
       # @return [Boolean]
       def initialized?
@@ -108,18 +82,104 @@ module Langfuse
 
       private
 
-      # Build HTTP headers for Langfuse OTLP endpoint
-      #
-      # @param public_key [String] Langfuse public API key
-      # @param secret_key [String] Langfuse secret API key
-      # @return [Hash] HTTP headers with Basic Auth
+      def existing_provider_for(config)
+        snapshot = tracing_config_snapshot(config)
+        if @config_snapshot == snapshot
+          config.logger.debug("Langfuse tracing already initialized; reusing existing tracer provider")
+        else
+          config.logger.warn(
+            "Langfuse tracing is already initialized. Changes to #{TRACING_CONFIG_FIELDS.join(', ')} " \
+            "require Langfuse.reset! before they take effect."
+          )
+        end
+        @tracer_provider
+      end
+
+      def publish_provider(provider, snapshot)
+        created = false
+        current = nil
+
+        # This mutex only guards publication so setup never exposes a half-built provider.
+        setup_mutex.synchronize do
+          if @tracer_provider
+            current = @tracer_provider
+          else
+            @tracer_provider = provider
+            @config_snapshot = snapshot
+            current = provider
+            created = true
+          end
+        end
+
+        [current, created]
+      end
+
+      def rollback_provider(provider)
+        setup_mutex.synchronize do
+          return unless @tracer_provider.equal?(provider)
+
+          @tracer_provider = nil
+          @config_snapshot = nil
+        end
+        provider.shutdown(timeout: 1)
+      rescue StandardError
+        nil
+      end
+
+      def build_tracer_provider(config)
+        provider = OpenTelemetry::SDK::Trace::TracerProvider.new(
+          sampler: build_sampler(config.sample_rate)
+        )
+        provider.add_span_processor(
+          SpanProcessor.new(config: config, exporter: build_exporter(config))
+        )
+        provider
+      end
+
+      def build_exporter(config)
+        OpenTelemetry::Exporter::OTLP::Exporter.new(
+          endpoint: "#{config.base_url}/api/public/otel/v1/traces",
+          headers: build_headers(config.public_key, config.secret_key),
+          compression: "gzip"
+        )
+      end
+
+      def log_initialized(config)
+        mode = config.tracing_async ? "async" : "sync"
+        config.logger.info("Langfuse tracing initialized with OpenTelemetry (#{mode} mode)")
+      end
+
+      def validate_tracing_config!(config)
+        raise ConfigurationError, "public_key is required" if blank?(config.public_key)
+        raise ConfigurationError, "secret_key is required" if blank?(config.secret_key)
+        raise ConfigurationError, "base_url cannot be empty" if blank?(config.base_url)
+        return if config.should_export_span.nil? || config.should_export_span.respond_to?(:call)
+
+        raise ConfigurationError, "should_export_span must respond to #call"
+      end
+
+      def tracing_config_snapshot(config)
+        TRACING_CONFIG_FIELDS.to_h { |field| [field, config.public_send(field)] }.freeze
+      end
+
+      def setup_mutex
+        @setup_mutex ||= Mutex.new
+      end
+
+      def blank?(value)
+        value.nil? || value.empty?
+      end
+
       def build_headers(public_key, secret_key)
         credentials = "#{public_key}:#{secret_key}"
         encoded = Base64.strict_encode64(credentials)
-        {
-          "Authorization" => "Basic #{encoded}"
-        }
+        { "Authorization" => "Basic #{encoded}" }
+      end
+
+      def build_sampler(sample_rate)
+        Sampling.build_sampler(sample_rate) || OpenTelemetry::SDK::Trace::Samplers::ALWAYS_ON
       end
     end
   end
+  # rubocop:enable Metrics/ModuleLength
 end

data/lib/langfuse/prompt_renderer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "mustache"
+
+module Langfuse
+  # Renders prompt templates with Langfuse SDK-compatible variable semantics.
+  #
+  # @api private
+  class PromptRenderer < Mustache
+    # Langfuse variables are model input, not browser output; JS/Python SDKs substitute raw values.
+    #
+    # @param value [Object] Value to insert into the prompt
+    # @return [String] Raw string representation
+    def escape(value)
+      value.to_s
+    end
+  end
+end

data/lib/langfuse/sampling.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Langfuse
+  # Shared sampling helpers for trace and score emission.
+  #
+  # @api private
+  module Sampling
+    module_function
+
+    # Build the sampler used by both trace export and trace-linked score emission.
+    #
+    # @param sample_rate [Float] Sampling rate from 0.0 to 1.0
+    # @return [OpenTelemetry::SDK::Trace::Samplers::TraceIdRatioBased, nil]
+    def build_sampler(sample_rate)
+      return nil if sample_rate >= 1.0
+
+      OpenTelemetry::SDK::Trace::Samplers::TraceIdRatioBased.new(sample_rate)
+    end
+  end
+end

data/lib/langfuse/score_client.rb

@@ -31,6 +31,8 @@ module Langfuse
     # @return [Logger] Logger instance
     attr_reader :logger
 
+    HEX_TRACE_ID_PATTERN = /\A[0-9a-f]{32}\z/
+
     # Initialize a new ScoreClient
     #
     # @param api_client [ApiClient] The API client for sending batches
@@ -43,6 +45,9 @@ module Langfuse
       @mutex = Mutex.new
       @flush_thread = nil
       @shutdown = false
+      # Match the immutable tracing setup contract: once this client exists, later config
+      # mutations must not change score sampling without rebuilding the client.
+      @score_sampler = Sampling.build_sampler(config.sample_rate)
 
       start_flush_timer
     end
@@ -76,28 +81,19 @@ module Langfuse
     def create(name:, value:, id: nil, trace_id: nil, session_id: nil, observation_id: nil, comment: nil,
                metadata: nil, environment: nil, data_type: :numeric, dataset_run_id: nil, config_id: nil)
       validate_name(name)
-      # Keep identifier policy server-side to preserve cross-SDK parity and avoid blocking valid future payloads.
       normalized_value = normalize_value(value, data_type)
       data_type_str = Types::SCORE_DATA_TYPES[data_type] || raise(ArgumentError, "Invalid data_type: #{data_type}")
 
+      return unless enqueue_trace_linked_score?(trace_id)
+
       event = build_score_event(
-        name: name,
-        value: normalized_value,
-        id: id,
-        trace_id: trace_id,
-        session_id: session_id,
-        observation_id: observation_id,
-        comment: comment,
-        metadata: metadata,
-        environment: environment,
-        data_type: data_type_str,
-        dataset_run_id: dataset_run_id,
-        config_id: config_id
+        name: name, value: normalized_value, id: id, trace_id: trace_id,
+        session_id: session_id, observation_id: observation_id, comment: comment,
+        metadata: metadata, environment: environment, data_type: data_type_str,
+        dataset_run_id: dataset_run_id, config_id: config_id
       )
 
       @queue << event
-
-      # Trigger flush if batch size reached
       flush if @queue.size >= config.batch_size
     rescue StandardError => e
       logger.error("Langfuse score creation failed: #{e.message}")
@@ -294,14 +290,43 @@ module Langfuse
     # @return [Hash] Hash with :trace_id and :observation_id (may be nil)
     def extract_ids_from_active_span
       span = OpenTelemetry::Trace.current_span
-      return { trace_id: nil, observation_id: nil } unless span&.recording?
+      span_context = span&.context
+      return { trace_id: nil, observation_id: nil } unless span_context&.valid?
 
       {
-        trace_id: span.context.trace_id.unpack1("H*"),
-        observation_id: span.context.span_id.unpack1("H*")
+        trace_id: span_context.trace_id.unpack1("H*"),
+        observation_id: span_context.span_id.unpack1("H*")
       }
     end
 
+    # Score sampling is decided purely by the configured sampler on the trace_id hash,
+    # matching langfuse-python. Non-hex trace ids and session/dataset-only scores bypass sampling.
+    def enqueue_trace_linked_score?(trace_id)
+      return true if trace_id.nil?
+      return true unless HEX_TRACE_ID_PATTERN.match?(trace_id)
+
+      sampler = score_sampler
+      return true if sampler.nil?
+      return true unless sampler.respond_to?(:should_sample?)
+
+      sample_result = sampler.should_sample?(
+        trace_id: [trace_id].pack("H*"),
+        parent_context: nil,
+        links: [],
+        name: "score",
+        kind: OpenTelemetry::Trace::SpanKind::INTERNAL,
+        attributes: {}
+      )
+      sample_result.sampled?
+    rescue StandardError => e
+      logger.warn("Langfuse score sampling fallback for trace_id=#{trace_id}: #{e.message}")
+      true
+    end
+
+    # Sampler is pinned at ScoreClient construction to match the "sample_rate requires reset!"
+    # contract and to keep each client's sampling scoped to its own config.
+    attr_reader :score_sampler
+
     # Send a batch of events to the API
     #
     # @param events [Array<Hash>] Array of event hashes

data/lib/langfuse/span_filter.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Langfuse
+  # Instrumentation scope name used by module-level Langfuse tracing.
+  LANGFUSE_TRACER_NAME = "langfuse-rb"
+
+  # Conservative allowlist of instrumentation scope prefixes that clearly belong to LLM workflows.
+  KNOWN_LLM_INSTRUMENTATION_SCOPE_PREFIXES = [
+    LANGFUSE_TRACER_NAME,
+    "agent_framework",
+    "ai",
+    "haystack",
+    "langsmith",
+    "litellm",
+    "openinference",
+    "opentelemetry.instrumentation.anthropic",
+    "strands-agents",
+    "vllm"
+  ].freeze
+
+  # Matched per span in the export path, so avoid allocating the dotted form each call.
+  KNOWN_LLM_INSTRUMENTATION_SCOPE_DOTTED_PREFIXES =
+    KNOWN_LLM_INSTRUMENTATION_SCOPE_PREFIXES.map { |prefix| "#{prefix}." }.freeze
+  private_constant :KNOWN_LLM_INSTRUMENTATION_SCOPE_DOTTED_PREFIXES
+
+  class << self
+    # Return whether the span was created by Langfuse's tracer.
+    #
+    # @param span [#instrumentation_scope] Span or span data to inspect
+    # @return [Boolean]
+    def langfuse_span?(span)
+      instrumentation_scope_name(span) == LANGFUSE_TRACER_NAME
+    end
+
+    # Return whether the span contains `gen_ai.*` attributes.
+    #
+    # @param span [#attributes] Span or span data to inspect
+    # @return [Boolean]
+    def genai_span?(span)
+      attributes = span.attributes
+      return false unless attributes
+
+      attributes.keys.any? { |key| key.is_a?(String) && key.start_with?("gen_ai.") }
+    end
+
+    # Return whether the span came from a known LLM instrumentation scope.
+    #
+    # @param span [#instrumentation_scope] Span or span data to inspect
+    # @return [Boolean]
+    def known_llm_instrumentor?(span)
+      scope_name = instrumentation_scope_name(span)
+      return false unless scope_name
+
+      return true if KNOWN_LLM_INSTRUMENTATION_SCOPE_PREFIXES.include?(scope_name)
+
+      KNOWN_LLM_INSTRUMENTATION_SCOPE_DOTTED_PREFIXES.any? do |dotted_prefix|
+        scope_name.start_with?(dotted_prefix)
+      end
+    end
+
+    # Return whether a span should be exported when no custom filter is configured.
+    #
+    # @param span [#instrumentation_scope, #attributes] Span or span data to inspect
+    # @return [Boolean]
+    def default_export_span?(span)
+      langfuse_span?(span) || genai_span?(span) || known_llm_instrumentor?(span)
+    end
+
+    # Cross-SDK parity keeps the `is_*` names public for compatibility.
+    alias is_langfuse_span langfuse_span?
+    alias is_genai_span genai_span?
+    alias is_known_llm_instrumentor known_llm_instrumentor?
+    alias is_default_export_span default_export_span?
+
+    private
+
+    def instrumentation_scope_name(span)
+      span.instrumentation_scope&.name
+    end
+  end
+end