clojure Riemann project collectd

Question

Fondamentalement, je voudrais calculer le ratio entre deux flux. Pour ce faire, j'ai essayé quelque chose comme (comme dans le projet API Rieamann suggestion here):

(project [(service "cahe-miss") 
     (service "cache-all")] 
    (smap folds/quotient 
    (with :service "ratio" 
    index))) 

Ce qui fonctionne apparemment, mais après un certain temps, j'ai remarqué quelques-uns des résultats où miss calculé. Après le débogage journal j'ai fini avec la configuration suivante afin de voir ce qui se passe et proint les valeurs:

(project [(service "cache-miss") 
      (service "cache-all")] 
    (fn [[miss all]] 
    (if (or (nil? miss) (nil? all)) 
     (do nil) 
     (do (where (= (:time miss) (:time all)) 
     ;to print time marks 
     (println (:time all)) 
     (println (:time miss)) 
     ; to distinguish easily each event 
     (println "NEW LINE") 
    )) 
    ) 
) 
) 

Ma surprise est que chaque fois que je reçois de nouvelles données de collectd (toutes les 10 secondes) la fonction I créé est exécuté deux fois, comme la réutilisation des données inutilisées précédentes, et plus il semble que cela ne se soucie pas du tout de ma contrainte d'égalité de temps dans le (où (=: temps ....) clasue.Le problème est que je divise les métriques avec différents horodatage ci-dessous quelques ouput du code précédent.

1445606294 
1445606294 
NEW LINE -- First time I get data 
1445606304 
1445606294 
NEW LINE 
1445606304 
1445606304 
NEW LINE -- Second time I get data 
1445606314 
1445606304 
NEW LINE 
1445606314 
1445606314 
NEW LINE -- Third time I get data 

Est-ce qu'il ya quelqu'un qui peut donner une indication sur la façon d'obtenir les données formatées comme je l'attendais? Je suppose qu'il y a quelque chose que je ne comprends pas à propos de la fonction "projet". Ou quelque chose lié à la façon dont les données entrantes sont traitées dans riemann.

Merci d'avance!

Mise à jour

je réussi à résoudre mon problème mais je n'ai pas une idée claire de la façon dont cela fonctionne, mais je réussi à le faire. En ce moment, je reçois deux flux différents de plug-in de queue collectd (à partir des journaux de nginx) et je réussi à faire le quotient entre eux comme suit:

(where (or (service "nginx/counter-cacheHit") (service "nginx/counter-cacheAll")) 
    (coalesce 
     (smap folds/quotient (with :service "cacheHit" (scale (* 1 100) index))))) 

Je l'ai testé largement et jusqu'à ce produit maintenant le droit résultats. Cependant, je ne comprends toujours pas plusieurs choses ... Tout d'abord, comment est-ce que la coalescence ne renvoie des données qu'après le traitement des deux événements. Collectd envoie les événements des deux flux toutes les deux secondes avec la même marque temporelle, usin "project" au lieu de "coalesce" aboutit à deux exécutions différentes de smap toutes les deux secondes (une pour chaque événement), mais les résultats coalescent ne sont obtenus qu'avec une seule exécution de smap avec les deux événements avec la même marque de temps, ce qui est exactement ce que je voulais. Enfin, je ne sais pas quel est le critère à choisir, c'est-à-dire le numérateur et le dénominateur. Est-ce parce que les clauses "ou" de la clause "where" sont utilisées?

Quoi qu'il en soit, avec un peu Blackmagic derrière elle, mais je suis parvenu à résoudre mon problème; ^)

Merci à tous!

Answer 1

en prenant les rapports entre les flux qui, lorsque le déplacement à des vitesses différentes ne fonctionnait pas pour moi. Depuis, j'ai décidé de calculer les ratios et les taux dans un intervalle de temps fixe ou un intervalle de temps mobile. De cette façon, vous capturez un instantané cohérent des événements dans un bloc de temps et calculez par dessus. Voici un code élidée de comparaison de la vitesse d'un service reçoit des événements à la vitesse à laquelle il est événements expédition:

(moving-time-window 30 ;; seconds 
    (smap (fn [events] 
      (let [in (or (->> events 
          (filter #(= (:service %) "event-received")) 
          count) 
         0) 
       out (or (->> events 
          (filter #(= (:service %) "event-sent")) 
          count) 
         0) 
       flow-rate (float (if (> in 0) (/ out in) 0))] 
      {:service "flow rate" 
      :metric flow-rate 
      :host "All" 
      :state (if (< flow-rate 0.99) "WARNING" "OK") 
      :time (:time (last events)) 
      :ttl default-interval})) 
     (tag ["some" "tags" "here"] index) 
     (where (and 
       (< (:metric event) 0.9) 
       (= (:environment event) "production")) 
       (throttle 1 3600 send-to-slack)))) 

Cela prend dans une fenêtre fixe d'événements, calcule le rapport de ce bloc et émet un événement contenant ce rapport comme il est métrique. alors si la métrique est mauvaise, elle m'appelle mou.