flow_chat 0.6.1 → 0.7.0

data/lib/flow_chat/session/cache_session_store.rb

@@ -1,45 +1,101 @@
 module FlowChat
   module Session
     class CacheSessionStore
+      include FlowChat::Instrumentation
+
+      # Make context available for instrumentation enrichment
+      attr_reader :context
+
       def initialize(context, cache = nil)
         @context = context
         @cache = cache || FlowChat::Config.cache
 
         raise ArgumentError, "Cache is required. Set FlowChat::Config.cache or pass a cache instance." unless @cache
+
+        FlowChat.logger.debug { "CacheSessionStore: Initialized cache session store for session #{session_key}" }
+        FlowChat.logger.debug { "CacheSessionStore: Cache backend: #{@cache.class.name}" }
       end
 
       def get(key)
         return nil unless @context
 
+        FlowChat.logger.debug { "CacheSessionStore: Getting key '#{key}' from session #{session_key}" }
+
         data = @cache.read(session_key)
-        return nil unless data
+        session_id = @context["session.id"]
+
+        unless data
+          # Use instrumentation for cache miss
+          instrument(Events::SESSION_CACHE_MISS, {
+            session_id: session_id,
+            key: key.to_s
+          })
+          return nil
+        end
 
-        data[key.to_s]
+        value = data[key.to_s]
+
+        # Use instrumentation for cache hit and data get
+        instrument(Events::SESSION_CACHE_HIT, {
+          session_id: session_id,
+          key: key.to_s
+        })
+
+        instrument(Events::SESSION_DATA_GET, {
+          session_id: session_id,
+          key: key.to_s,
+          value: value
+        })
+
+        value
       end
 
       def set(key, value)
         return unless @context
 
+        FlowChat.logger.debug { "CacheSessionStore: Setting key '#{key}' = #{value.inspect} in session #{session_key}" }
+
         data = @cache.read(session_key) || {}
         data[key.to_s] = value
 
-        @cache.write(session_key, data, expires_in: session_ttl)
+        ttl = session_ttl
+        @cache.write(session_key, data, expires_in: ttl)
+
+        # Use instrumentation for data set
+        instrument(Events::SESSION_DATA_SET, {
+          session_id: @context["session.id"],
+          key: key.to_s
+        })
+
+        FlowChat.logger.debug { "CacheSessionStore: Session data saved with TTL #{ttl.inspect}" }
         value
       end
 
       def delete(key)
         return unless @context
 
+        FlowChat.logger.debug { "CacheSessionStore: Deleting key '#{key}' from session #{session_key}" }
+
         data = @cache.read(session_key)
-        return unless data
+        unless data
+          FlowChat.logger.debug { "CacheSessionStore: No session data found for deletion" }
+          return
+        end
 
         data.delete(key.to_s)
         @cache.write(session_key, data, expires_in: session_ttl)
+
+        FlowChat.logger.debug { "CacheSessionStore: Key '#{key}' deleted from session" }
       end
 
       def clear
         return unless @context
 
+        # Use instrumentation for session destruction
+        instrument(Events::SESSION_DESTROYED, {
+          session_id: @context["session.id"]
+        })
+
         @cache.delete(session_key)
       end
 
@@ -47,16 +103,20 @@ module FlowChat
       alias_method :destroy, :clear
 
       def exists?
-        @cache.exist?(session_key)
+        exists = @cache.exist?(session_key)
+        FlowChat.logger.debug { "CacheSessionStore: Session #{session_key} exists: #{exists}" }
+        exists
       end
 
       private
 
       def session_key
+        return "flow_chat:session:nil_context" unless @context
+
         gateway = @context["request.gateway"]
         msisdn = @context["request.msisdn"]
 
-        case gateway
+        key = case gateway
         when :whatsapp_cloud_api
           "flow_chat:session:whatsapp:#{msisdn}"
         when :nalo, :nsano
@@ -65,12 +125,15 @@ module FlowChat
         else
           "flow_chat:session:unknown:#{msisdn}"
         end
+
+        FlowChat.logger.debug { "CacheSessionStore: Generated session key: #{key}" }
+        key
       end
 
       def session_ttl
         gateway = @context["request.gateway"]
 
-        case gateway
+        ttl = case gateway
         when :whatsapp_cloud_api
           7.days  # WhatsApp conversations can be long-lived
         when :nalo, :nsano
@@ -78,6 +141,9 @@ module FlowChat
         else
           1.day   # Default
         end
+
+        FlowChat.logger.debug { "CacheSessionStore: Session TTL for #{gateway}: #{ttl.inspect}" }
+        ttl
       end
     end
   end

data/lib/flow_chat/session/middleware.rb

@@ -1,14 +1,39 @@
 module FlowChat
   module Session
     class Middleware
+      include FlowChat::Instrumentation
+
+      attr_reader :context
+
       def initialize(app)
         @app = app
+        FlowChat.logger.debug { "Session::Middleware: Initialized session middleware" }
       end
 
       def call(context)
-        context["session.id"] = session_id context
+        @context = context
+        session_id = session_id(context)
+        FlowChat.logger.debug { "Session::Middleware: Generated session ID: #{session_id}" }
+
+        context["session.id"] = session_id
         context.session = context["session.store"].new(context)
-        @app.call(context)
+
+        # Use instrumentation instead of direct logging for session creation
+        instrument(Events::SESSION_CREATED, {
+          session_id: session_id,
+          store_type: context["session.store"].name,
+          gateway: context["request.gateway"]
+        })
+
+        FlowChat.logger.debug { "Session::Middleware: Session store: #{context["session.store"].class.name}" }
+
+        result = @app.call(context)
+
+        FlowChat.logger.debug { "Session::Middleware: Session processing completed for #{session_id}" }
+        result
+      rescue => error
+        FlowChat.logger.error { "Session::Middleware: Error in session processing for #{session_id}: #{error.class.name}: #{error.message}" }
+        raise
       end
 
       private
@@ -16,17 +41,25 @@ module FlowChat
       def session_id(context)
         gateway = context["request.gateway"]
         flow_name = context["flow.name"]
+
+        FlowChat.logger.debug { "Session::Middleware: Building session ID for gateway=#{gateway}, flow=#{flow_name}" }
+
         case gateway
         when :whatsapp_cloud_api
           # For WhatsApp, use phone number + flow name for consistent sessions
           phone = context["request.msisdn"]
-          "#{gateway}:#{flow_name}:#{phone}"
+          session_id = "#{gateway}:#{flow_name}:#{phone}"
+          FlowChat.logger.debug { "Session::Middleware: WhatsApp session ID created for phone #{phone}" }
+          session_id
         # when :nalo, :nsano
         #   # For USSD, use the request ID from the gateway
         #   "#{gateway}:#{flow_name}:#{context["request.id"]}"
         else
           # Fallback to request ID
-          "#{gateway}:#{flow_name}:#{context["request.id"]}"
+          request_id = context["request.id"]
+          session_id = "#{gateway}:#{flow_name}:#{request_id}"
+          FlowChat.logger.debug { "Session::Middleware: Generic session ID created for request #{request_id}" }
+          session_id
         end
       end
     end

data/lib/flow_chat/session/rails_session_store.rb

@@ -1,27 +1,62 @@
 module FlowChat
   module Session
     class RailsSessionStore
+      include FlowChat::Instrumentation
+
+      # Make context available for instrumentation enrichment
+      attr_reader :context
+
       def initialize(context)
+        @context = context
         @session_id = context["session.id"]
         @session_store = context.controller.session
         @session_data = (session_store[session_id] || {}).with_indifferent_access
+
+        FlowChat.logger.debug { "RailsSessionStore: Initialized Rails session store for session #{session_id}" }
+        FlowChat.logger.debug { "RailsSessionStore: Loaded session data with #{session_data.keys.size} keys" }
       end
 
       def get(key)
-        session_data[key]
+        value = session_data[key]
+
+        # Use instrumentation for data get
+        instrument(Events::SESSION_DATA_GET, {
+          session_id: session_id,
+          key: key.to_s,
+          value: value
+        })
+
+        value
       end
 
       def set(key, value)
+        FlowChat.logger.debug { "RailsSessionStore: Setting key '#{key}' = #{value.inspect} in session #{session_id}" }
+
         session_data[key] = value
         session_store[session_id] = session_data
+
+        # Use instrumentation for data set
+        instrument(Events::SESSION_DATA_SET, {
+          session_id: session_id,
+          key: key.to_s
+        })
+
+        FlowChat.logger.debug { "RailsSessionStore: Session data saved to Rails session store" }
         value
       end
 
       def delete(key)
+        FlowChat.logger.debug { "RailsSessionStore: Deleting key '#{key}' from session #{session_id}" }
         set key, nil
       end
 
       def destroy
+        # Use instrumentation for session destruction
+        instrument(Events::SESSION_DESTROYED, {
+          session_id: session_id,
+          gateway: "rails" # Rails doesn't have a specific gateway context
+        })
+
         session_store[session_id] = nil
       end
 

data/lib/flow_chat/simulator/controller.rb

@@ -4,7 +4,7 @@ module FlowChat
       def flowchat_simulator
         # Set simulator cookie for authentication
         set_simulator_cookie
-        
+
         respond_to do |format|
           format.html do
             render inline: simulator_view_template, layout: false, locals: simulator_locals
@@ -51,7 +51,7 @@ module FlowChat
             color: "#25D366",
             settings: {
               phone_number: default_phone_number,
-              contact_name: default_contact_name,
+              contact_name: default_contact_name
             }
           }
         }
@@ -78,18 +78,18 @@ module FlowChat
       def set_simulator_cookie
         # Get global simulator secret
         simulator_secret = FlowChat::Config.simulator_secret
-        
+
         unless simulator_secret && !simulator_secret.empty?
           raise StandardError, "Simulator secret not configured. Please set FlowChat::Config.simulator_secret to enable simulator mode."
         end
-        
+
         # Generate timestamp-based signed cookie
         timestamp = Time.now.to_i
         message = "simulator:#{timestamp}"
         signature = OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new("sha256"), simulator_secret, message)
-        
+
         cookie_value = "#{timestamp}:#{signature}"
-        
+
         # Set secure cookie (valid for 24 hours)
         cookies[:flowchat_simulator] = {
           value: cookie_value,

data/lib/flow_chat/ussd/gateway/nalo.rb

@@ -4,11 +4,16 @@ module FlowChat
   module Ussd
     module Gateway
       class Nalo
+        include FlowChat::Instrumentation
+
+        attr_reader :context
+
         def initialize(app)
           @app = app
         end
 
         def call(context)
+          @context = context
           params = context.controller.request.params
 
           context["request.id"] = params["USERID"]
@@ -20,8 +25,33 @@ module FlowChat
           # context["request.type"] = params["MSGTYPE"] ? :initial : :response
           context.input = params["USERDATA"].presence
 
+          # Instrument message received when user provides input using new scalable approach
+          if context.input.present?
+            instrument(Events::MESSAGE_RECEIVED, {
+              from: context["request.msisdn"],
+              message: context.input,
+              session_id: context["request.id"],
+              gateway: :nalo,
+              platform: :ussd,
+              timestamp: context["request.timestamp"]
+            })
+          end
+
+          # Process the request and instrument the response
           type, prompt, choices, media = @app.call(context)
 
+          # Instrument message sent using new scalable approach
+          instrument(Events::MESSAGE_SENT, {
+            to: context["request.msisdn"],
+            session_id: context["request.id"],
+            message: context.input || "",
+            message_type: (type == :prompt) ? "prompt" : "terminal",
+            gateway: :nalo,
+            platform: :ussd,
+            content_length: prompt.to_s.length,
+            timestamp: context["request.timestamp"]
+          })
+
           context.controller.render json: {
             USERID: params["USERID"],
             MSISDN: params["MSISDN"],

data/lib/flow_chat/ussd/gateway/nsano.rb

@@ -4,11 +4,16 @@ module FlowChat
   module Ussd
     module Gateway
       class Nsano
+        include FlowChat::Instrumentation
+
+        attr_reader :context
+
         def initialize(app)
           @app = app
         end
 
         def call(context)
+          @context = context
           controller = context["controller"]
           controller.request
 
@@ -18,6 +23,34 @@ module FlowChat
           # Set a basic message_id (can be enhanced based on actual Nsano implementation)
           context["request.message_id"] = SecureRandom.uuid
 
+          # TODO: Implement Nsano-specific parameter parsing
+          # For now, add basic instrumentation structure for when this is implemented
+
+          # Placeholder instrumentation - indicates Nsano implementation is needed
+          instrument(Events::MESSAGE_RECEIVED, {
+            from: "TODO",  # Would be parsed from Nsano params
+            message: "TODO",  # Would be actual user input
+            session_id: "TODO",  # Would be Nsano session ID
+            gateway: :nsano,
+            platform: :ussd,
+            timestamp: context["request.timestamp"]
+          })
+
+          # Process request with placeholder app call
+          _, _, _, _ = @app.call(context) if @app
+
+          # Placeholder response instrumentation
+          instrument(Events::MESSAGE_SENT, {
+            to: "TODO",  # Would be actual phone number
+            session_id: "TODO",  # Would be Nsano session ID
+            message: "TODO",  # Would be actual response message
+            message_type: "prompt",  # Would depend on actual response type
+            gateway: :nsano,
+            platform: :ussd,
+            content_length: 0,  # Would be actual content length
+            timestamp: context["request.timestamp"]
+          })
+
           # input = context["rack.input"].read
           # context["rack.input"].rewind
           # if input.present?

data/lib/flow_chat/ussd/middleware/choice_mapper.rb

@@ -0,0 +1,109 @@
+module FlowChat
+  module Ussd
+    module Middleware
+      class ChoiceMapper
+        def initialize(app)
+          @app = app
+          FlowChat.logger.debug { "Ussd::ChoiceMapper: Initialized USSD choice mapping middleware" }
+        end
+
+        def call(context)
+          @context = context
+          @session = context.session
+
+          session_id = context["session.id"]
+          FlowChat.logger.debug { "Ussd::ChoiceMapper: Processing request for session #{session_id}" }
+
+          if intercept?
+            FlowChat.logger.info { "Ussd::ChoiceMapper: Intercepting request for choice resolution - session #{session_id}" }
+            handle_choice_input
+          end
+
+          # Clear choice mapping state for new flows
+          clear_choice_state_if_needed
+          type, prompt, choices, media = @app.call(context)
+
+          if choices.present?
+            FlowChat.logger.debug { "Ussd::ChoiceMapper: Found choices, creating number mapping" }
+            choices = create_numbered_mapping(choices)
+          end
+
+          [type, prompt, choices, media]
+        end
+
+        private
+
+        def intercept?
+          # Intercept if we have choice mapping state and user input is a number that maps to a choice
+          choice_mapping = get_choice_mapping
+          should_intercept = choice_mapping.present? &&
+            @context.input.present? &&
+            choice_mapping.key?(@context.input.to_s)
+
+          if should_intercept
+            FlowChat.logger.debug { "Ussd::ChoiceMapper: Intercepting - input: #{@context.input}, mapped to: #{choice_mapping[@context.input.to_s]}" }
+          end
+
+          should_intercept
+        end
+
+        def handle_choice_input
+          choice_mapping = get_choice_mapping
+          original_choice = choice_mapping[@context.input.to_s]
+
+          FlowChat.logger.info { "Ussd::ChoiceMapper: Resolving choice input #{@context.input} to #{original_choice}" }
+
+          # Replace the numeric input with the original choice
+          @context.input = original_choice
+        end
+
+        def create_numbered_mapping(choices)
+          # Choices are always a hash after normalize_choices
+          numbered_choices = {}
+          choice_mapping = {}
+
+          choices.each_with_index do |(key, value), index|
+            number = (index + 1).to_s
+            numbered_choices[number] = value
+            choice_mapping[number] = key.to_s
+          end
+
+          store_choice_mapping(choice_mapping)
+          FlowChat.logger.debug { "Ussd::ChoiceMapper: Created mapping: #{choice_mapping}" }
+          numbered_choices
+        end
+
+        def store_choice_mapping(mapping)
+          @session.set("ussd.choice_mapping", mapping)
+          FlowChat.logger.debug { "Ussd::ChoiceMapper: Stored choice mapping: #{mapping}" }
+        end
+
+        def get_choice_mapping
+          @session.get("ussd.choice_mapping") || {}
+        end
+
+        def clear_choice_mapping
+          @session.delete("ussd.choice_mapping")
+          FlowChat.logger.debug { "Ussd::ChoiceMapper: Cleared choice mapping" }
+        end
+
+        def clear_choice_state_if_needed
+          # Clear choice mapping if this is a new flow (no input or fresh start)
+          if @context.input.blank? || should_clear_for_new_flow?
+            clear_choice_mapping
+          end
+        end
+
+        def should_clear_for_new_flow?
+          # Clear mapping if this input doesn't match any stored mapping
+          # This indicates we're in a new flow step
+          choice_mapping = get_choice_mapping
+          return false if choice_mapping.empty?
+
+          # If input is present but doesn't match any mapping, we're in a new flow
+          @context.input.present? && !choice_mapping.key?(@context.input.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/flow_chat/ussd/middleware/executor.rb

@@ -4,22 +4,44 @@ module FlowChat
       class Executor
         def initialize(app)
           @app = app
+          FlowChat.logger.debug { "Ussd::Executor: Initialized USSD executor middleware" }
         end
 
         def call(context)
+          flow_class = context.flow
+          action = context["flow.action"]
+          session_id = context["session.id"]
+
+          FlowChat.logger.info { "Ussd::Executor: Executing flow #{flow_class.name}##{action} for session #{session_id}" }
+
           ussd_app = build_ussd_app context
-          flow = context.flow.new ussd_app
-          flow.send context["flow.action"]
+          FlowChat.logger.debug { "Ussd::Executor: USSD app built for flow execution" }
+
+          flow = flow_class.new ussd_app
+          FlowChat.logger.debug { "Ussd::Executor: Flow instance created, invoking #{action} method" }
+
+          flow.send action
+          FlowChat.logger.warn { "Ussd::Executor: Flow execution failed to interact with user for #{flow_class.name}##{action}" }
+          raise FlowChat::Interrupt::Terminate, "Unexpected end of flow."
         rescue FlowChat::Interrupt::Prompt => e
+          FlowChat.logger.info { "Ussd::Executor: Flow prompted user - Session: #{session_id}, Prompt: '#{e.prompt.truncate(100)}'" }
+          FlowChat.logger.debug { "Ussd::Executor: Prompt details - Choices: #{e.choices&.size || 0}, Has media: #{!e.media.nil?}" }
           [:prompt, e.prompt, e.choices, e.media]
         rescue FlowChat::Interrupt::Terminate => e
+          FlowChat.logger.info { "Ussd::Executor: Flow terminated - Session: #{session_id}, Message: '#{e.prompt.truncate(100)}'" }
+          FlowChat.logger.debug { "Ussd::Executor: Destroying session #{session_id}" }
           context.session.destroy
           [:terminate, e.prompt, nil, e.media]
+        rescue => error
+          FlowChat.logger.error { "Ussd::Executor: Flow execution failed - #{flow_class.name}##{action}, Session: #{session_id}, Error: #{error.class.name}: #{error.message}" }
+          FlowChat.logger.debug { "Ussd::Executor: Stack trace: #{error.backtrace.join("\n")}" }
+          raise
         end
 
         private
 
         def build_ussd_app(context)
+          FlowChat.logger.debug { "Ussd::Executor: Building USSD app instance" }
           FlowChat::Ussd::App.new(context)
         end
       end