fallback_stats.clj

gistfile1.clj

(defn fallback-stats [d b] (with-db d 
                             
  (def old-buckets buckets)
                    
  (def browser (if (= b "chrome") chrome? (complement chrome?)))
                             
  (defn div [bucket query] (filter (partial query) bucket))

  (defn sub [bucket res] (clojure.set/difference (set bucket) (set res)))

                             
  (def fallbacks (filter browser (get-flash-sessions)))

  (def old-sessions (div fallbacks {:message "flash_fallback" "json_data.ice_connection_state" {$exists false}}))
  
  (def new-sessions (filter 
          (partial any? 
                   {:message "flash_fallback" 
                    "json_data.ice_connection_state" {$exists true}
                    }) fallbacks))
  
  (def reconnect-sessions (filter 
          (partial any? 
                   {:message "webrtc_connection_data"
                    }) new-sessions))
  
  (def noreconnect-sessions (clojure.set/difference (set new-sessions) (set reconnect-sessions)))
  
  (def got-signalling-channel (filter 
          (partial any? 
                   {:message "client_connect_to_peer_server"
                    }) noreconnect-sessions))
  
  (def no-signalling-channel (clojure.set/difference (set noreconnect-sessions) (set got-signalling-channel)))
  
  (def sent-offer (filter 
          (partial any? 
                   {:message "signalling_offer"
                    }) got-signalling-channel))
  
  (def no-sent-offer (clojure.set/difference (set got-signalling-channel) (set sent-offer)))
  
  (def got-offer (filter 
          (partial any? 
                   {:message "client_offer_received"
                    }) sent-offer))
  
  (def no-offer (clojure.set/difference (set sent-offer) (set got-offer)))
  
  (def got-audio-stream (filter 
          (partial any? 
                   {:message "client_audio_stream"
                    }) got-offer))
  
  (def no-audio-stream (clojure.set/difference (set got-offer) (set got-audio-stream)))
  
  (def sent-answer (filter 
          (partial any? 
                   {:message "client_answer_sent"
                    }) got-audio-stream))
  
  (def no-answer (clojure.set/difference (set got-audio-stream) (set sent-answer)))
  
  
  
  (def winphone (filter 
          (partial any? 
                   {:message "chromium-running" "json_data.terminal_type" "winphone"
                    }) sent-answer))
  
  (def no-winphone (clojure.set/difference (set sent-answer) (set winphone)))
  
  
  (def macs (filter 
          (partial any? 
                   {:message "chromium-running" 
                    "json_data.terminal_type" {$in ["yos"]} 
                    "json_data.machine" {$in ["185.44.129.86" "185.44.129.202"]}
                    }) no-winphone))
  
  (def no-macs (clojure.set/difference (set no-winphone) (set macs)))
  
                             
  (def kaazing-sessions (filter 
          (partial any? 
                   {:message "live_session_report"
                    "json_data.kaazing_error" false
                    }) no-macs))
  
  (def nokaazing-sessions (clojure.set/difference (set no-macs) (set kaazing-sessions)))
                             
  (def used-kaazing-sessions (filter 
          (partial any? 
                   {:message "used Kaazing"
                    }) nokaazing-sessions))
                             
  (def kaazing-sessions (clojure.set/union (set kaazing-sessions) (set used-kaazing-sessions)))
  (def nokaazing-sessions (clojure.set/difference (set nokaazing-sessions) (set used-kaazing-sessions)))
                             
  
  (def got-srflx (filter 
          (partial any? 
                   {:message "client_candidate_data" "json_data.srflx" true
                    }) nokaazing-sessions))
                             
  (def no-srflx (clojure.set/difference (set nokaazing-sessions) (set got-srflx)))
  
  
  
  (def retry-sessions (filter 
          (partial any? 
                   {:message "retry_with_only_turn"
                    }) got-srflx))
                             
  (def noretry-sessions (clojure.set/difference (set got-srflx) (set retry-sessions)))
  
  
  
  (def video-stream-event (filter 
          (partial any? 
                   {:message "client_video_stream"
                    }) noretry-sessions))
  
  (def no-video-stream-event (clojure.set/difference (set noretry-sessions) (set video-stream-event)))
  
  (def gathering-timeout (filter 
          (partial any? 
                   {:message "client_reconnecting_with_gathering_timeout"
                    }) no-video-stream-event))
  
  (def no-gathering-timeout (clojure.set/difference (set no-video-stream-event) (set gathering-timeout)))
  
  
  (defn lp [n s i] (vector s n (/ (* 100.00 n) (count new-sessions)) (- n (get-in old-buckets [i 1]))))
  
  (def results {
            :total_fallback_sessions (count fallbacks)
            :old-sessions (count old-sessions)
            :new-sessions (count new-sessions)
          })
  
  (def buckets {
            :kaazing-sessions (lp (count kaazing-sessions) "no udp, fallback with kaazing" :kaazing-sessions)
            :reconnect-sessions (lp (count reconnect-sessions) "fallback after webrtc froze" :reconnect-sessions)
            :winphone (lp (count winphone) "winphone terminals old deploy" :winphone)
            :macs (lp (count macs) "mac terminals old deploy" :macs)
            :no-srflx (lp (count no-srflx) "no srflx candidates" :no-srflx)
            :retry-sessions (lp (count retry-sessions) "fallback after retry with only turn" :retry-sessions)
            
            :no-signalling-channel (lp (count no-signalling-channel) "no socketio connection" :no-signalling-channel)
            :no-sent-offer (lp (count no-sent-offer) "no offer sent from terminal" :no-sent-offer)
            :no-offer (lp (count no-offer) "no offer received on client" :no-offer)
            :no-audio-stream (lp (count no-audio-stream) "no audio stream event received" :no-audio-stream)
            :no-answer (lp (count no-answer) "no answer sent" :no-answer)
            :gathering-timeout (lp (count gathering-timeout) "gathering timeout after 3 seconds" :gathering-timeout)
                 
            ;:no-gathering-timeout (lp (count no-gathering-timeout) "no gathering timeout yet fallback" :no-gathering-timeout)
            ;:video-stream-event (lp (count video-stream-event) "video streamed yet fallback" :video-stream-event)
            ;:fallback-timer-timedout (lp (count fallback-timer-timedout) "fallback timer timed out")
            ;:internet-disconnected (lp (count internet-disconnected) "internet disconnected")
                 })
  
  (defn tabulate [] (table/table-view (conj (vec (cons [:reason, :sessions, :percent, :increase] (reverse (sort-by second (vals buckets))))) [:total (reduce + (map second (vals buckets))) (reduce + (map #(nth % 2) (vals buckets))) (reduce + (map #(nth % 3) (vals buckets)))])))
  
  ;(pprint results)
  ;(print "\n")
  ;(pprint buckets)
  ;(print "\n")
  ;(pprint (str "Total " (reduce + (map second (vals buckets))) " " (results :new-sessions)))
  )
  
  (tabulate)
 )