Share
Wenn Sie sich mit New Relic vertraut machen, ist es leicht, von allen Funktionen überwältigt zu werden. Aber wie bei den meisten Tools: Wenn Sie langsam die Lernkurve erklimmen und sich mit den Funktionen aus der Box vertraut machen, beginnen Sie sich zu fragen, wie alles unter der Haube hängt und ob Sie mit dem, was Sie haben, mehr tun können Hand.
Heute werde ich sehen, wie New Relic Transaktionen tatsächlich überwacht und wie Sie sich in den Prozess einbinden können. Wir werden einen kurzen Blick auf die Unterstützung werfen, die New Relic für das Überwachen von Hintergrundjobs bietet, und wir werden auch die benutzerdefinierten Metriken von New Relic kennenlernen, wie Sie diese verwenden und welche Vorteile Sie daraus ziehen. Am Ende werden Sie ein tieferes Verständnis für die Funktionsweise von New Relic haben und in der Lage sein, es besser zu nutzen. Mit anderen Worten, wir werden ein tieferes Wissen über unsere Tools haben - etwas, das jeder Entwickler anstreben sollte.
Beginnen wir mit einem kurzen Blick darauf, wie sich New Relic tatsächlich einfügt, um die Leistung Ihrer Anwendung zu verfolgen.
Gesponserter InhaltDieser Inhalt wurde von New Relic in Auftrag gegeben und vom Tuts + Team verfasst und / oder bearbeitet. Unser Ziel mit gesponserten Inhalten ist es, relevante und objektive Tutorials, Fallstudien und inspirierende Interviews zu veröffentlichen, die unseren Lesern einen echten erzieherischen Wert bieten und die Erstellung nützlicherer Inhalte ermöglichen.
Es mag ein bisschen wie Magie aussehen, Sie fügen einen Edelstein in Ihren ein Gemfile:
gem 'newrelic_rpm'
Und irgendwie überwacht New Relic Ihren gesamten Code. Natürlich handelt es sich nur um Code. Sehen wir uns also an, wie New Relic Ihre App tatsächlich so ausstattet, dass sie mit der Überwachung beginnen kann, wenn der Agenten-Gem benötigt wird. Wir werden dies im Rahmen einer Rails 4-App tun.
Der erste Ort zum schauen ist newrelic_rpm.rb, welches den folgenden relevanten Code enthält:
… Wenn Rails :: VERSION :: MAJOR.to_i> = 3 Modul NewRelic-Klasse Railtie < Rails::Railtie initializer "newrelic_rpm.start_plugin" do |app| NewRelic::Control.instance.init_plugin(:config => app.config) Ende Ende Ende sonst…
Eine Railtie wird also erstellt, wenn die Rails-Version über drei liegt NewRelic :: Control Singleton-Instanz (wenn es initialisiert wird) und Aufrufe init_plugin. Wenn der NewRelic :: Control Es wird eine Instanz erstellt, die ermittelt, welches Framework gerade läuft (in unserem Fall Rails 4) und ein paar relevante Codes geladen werden. wir können das in sehen new_relic / control / class_methods # load_framework_class. Das init_plugin Methode, die ausgeführt wird, lebt in new_relic / control / instance_methods. Der interessante Code hier ist:
… Wenn Agent.config [: agent_enabled] &&! NewRelic :: Agent.instance.started ist? start_agent install_instrumentation load_samplers, außer Agent.config [: disable_samplers]…
Das install_instrumentation Anruf ist der wichtigste. Die Umsetzung lebt in new_relic / control / instrumentation. Beim Überspringen der Boilerplate-Bits wird ermittelt, welche Instrumentierungsdateien geladen werden müssen, und diese dann einzeln benötigt. In unserem Fall werden Dateien unter geladen new_relic / agent / instrumentation / schienen4. Eine der Dateien hier ist action_controller.rb, Wenn dies erforderlich ist, wird der folgende Code über eine Metaprogramm-Magie ausgeführt:
führt die Klasse ActionController :: Base include aus NewRelic :: Agent :: Instrumentation :: ControllerInstrumentation enthält NewRelic :: Agent :: Instrumentation :: Rails4 :: ActionController und NewRelic :: Agent :: Instrumentation :: ActionControllerSubscriber \ .subscribe (/ ^ process_action .action_controller $ /) end
Und hier kommen wir zum Kernpunkt: ActionController :: Base (von dem alle Ihre Controller erben) enthält ein paar Module, von denen das wichtigste das ist NewRelic :: Agent :: Instrumentation :: ControllerInstrumentation. Damit beginnt New Relic damit, alle Ihre Controller-Aktionen als "Transaktionen" zu überwachen. Natürlich ist dies eine etwas vereinfachte Ansicht und wir haben eine Menge Details im Detail, aber Sie erhalten eine Vorstellung davon, wie New Relic Ihren Code überwacht. Die Frage ist, wie Sie diese Informationen verwenden können?
Es ist sehr unwahrscheinlich, dass Sie sich in einer Situation befinden, in der Sie ein Web-Framework verwenden, für das New Relic nicht bereits über Instrumente verfügt (in der Ruby-Welt). Nehmen wir an, Sie haben es getan. Da wir wissen, was wir jetzt wissen, können wir die Controller-Aktionen dieses benutzerdefinierten Frameworks manuell manuell instrumentieren. Wenn wir einen Controller wie diesen haben:
Klasse CustomController def custom_action… end end
Wir können es so instrumentieren:
Die Klasse CustomController enthält NewRelic :: Agent :: Instrumentation :: ControllerInstrumentation def custom_action… end add_transaction_tracer: custom_action end
Jetzt wird Ihre Controller-Methode wie eine Transaktion auf dieselbe Weise verfolgt, wie Rails-Aktionen verfolgt werden. Wenn Sie Ihr eigenes Web-Framework mit Datenbank-Handling-Code gerollt haben, müssen Sie natürlich einen großen Teil des Codes instrumentieren, damit New Relic nicht nur Controller-Aktionen überwachen kann. Die generelle Idee bleibt jedoch solide.
Das obige Muster wird nützlicher, wenn New Relic Hintergrundjobs in Ihrer Anwendung verfolgen soll. Es ist viel wahrscheinlicher, dass Sie einen benutzerdefinierten Code für die Verarbeitung von Hintergrundjobs gewürfelt haben, als wenn Sie Ihr eigenes Web-Framework geschrieben haben. Tuts + haben wir anfangs genau so gemacht, obwohl wir jetzt zu Sidekiq migrieren. Wenn Sie eines der bekannten Hintergrund-Job-Systeme wie Sidekiq, Resque oder Delayed Job verwenden, sind in New Relic bereits Instrumente integriert. Wenn Sie jedoch Ihre eigenen Rollen haben, genügt das obige Muster, um Ihre Aufgaben zu überwachen.
Zum Beispiel waren unsere benutzerdefinierten Tuts + Hintergrundjobs reguläre Ruby-Klassen, die auf die ausführen Methode, also müssen wir nur folgendes tun:
Die Klasse SomeBackgroundJob enthält NewRelic :: Agent :: Instrumentation :: ControllerInstrumentation def Ausführen… end add_transaction_tracer: custom_action, category:: task end
Das letzte Stück, Kategorie:: Aufgabe, soll sicherstellen, dass New Relic es nicht als Web-Transaktion erfasst, sondern als Hintergrundaufgabe behandelt und auf der Registerkarte "Hintergrundaufgaben" in der New Relic-Benutzeroberfläche angezeigt wird. Wenn wir eine Basisklasse für alle unsere Jobs erstellen, können wir die Instrumentierung dort ablegen, und untergeordnete Klassen erben sie, sodass wir uns nicht in jeder Jobklasse um das oben genannte kümmern müssen.
Interessanterweise sind selbst die von New Relic automatisch überwachten Web-Transaktionen nicht unangemessen. Sie können beispielsweise einige benutzerdefinierte Parameter hinzufügen, die an New Relic für die gerade ausgeführte Transaktion gesendet werden sollen (wenn Sie die Parameter für die Erfassung aktiviert haben)..
Sie können dies jederzeit während der Transaktion tun. Sie müssen nur anrufen :: NewRelic :: Agent.add_custom_parameters (: key => 'value') Zu jedem Zeitpunkt werden die von Ihnen übergebenen Parameter zu den Parameterdaten hinzugefügt, die Sie in New Relic sehen. Wenn wir zum Beispiel einen Controller hätten, der so aussah:
Klasse HelloController < ApplicationController def index ::NewRelic::Agent.add_custom_parameters(:hello => "Welt") Ende Ende
Langsame Transaktionen würden uns folgendes geben:
Das ist nicht alles, was wir tun können. Wir können eine Transaktion während der Ausführung segmentieren, indem Sie sie umbenennen. Angenommen, wir möchten eine Transaktion als besonders behandeln, wenn sie von einem bestimmten Benutzer ausgeführt wird. Sie können so etwas tun:
Accentsconagua
Klasse HelloController < ApplicationController def index new_relic_name = NewRelic::Agent.get_transaction_name if current_user.name == 'Joe Customer' NewRelic::Agent.set_transaction_name("#new_relic_name - Joe Customer") end end end Diese Transaktion wird nun als separate Transaktion in der New Relic-Benutzeroberfläche behandelt:
Selbst die standardmäßigen New Relic-Instrumente bieten Spielraum für Anpassungen, aber manchmal benötigen Sie, genau wie Captain Kirk, nur mehr Leistung. Hier kommen benutzerdefinierte Metriken ins Spiel.
Früher hatten Sie benutzerdefinierte Kennzahlen verwendet, um beispielsweise die Kommunikation externer Dienste und die Verwendung verschiedener gängiger Tools wie Redis zu überwachen. Heutzutage bietet New Relic bessere Möglichkeiten zur Überwachung dieser Informationen. Wofür brauchen wir benutzerdefinierte Kennzahlen? Ich habe herausgefunden, dass benutzerdefinierte Metriken in vier Situationen nützlich sind:
Werfen wir einen kurzen Blick auf jeden von ihnen.
New Relic ist ziemlich gut darin, die Leistung Ihrer verschiedenen Anwendungsmethoden in einer Transaktionsablaufverfolgung aufzuschlüsseln, aber manchmal werden Sie Folgendes in einer Ablaufverfolgung sehen:
Es scheint, dass es Anwendungscode gibt, den New Relic aus irgendeinem Grund nicht instrumentieren konnte. Wir können New Relic (und uns selbst) mit einigen benutzerdefinierten Metriken helfen. Wir müssen herausfinden, welche Methode New Relic Probleme beim Überwachen hatte und einige benutzerdefinierte Metriken einhaken, um zu verfolgen, wie lange die Ausführung dieser Methode dauerte. Dies erscheint dann in allen nachfolgenden Spuren. Nehmen wir an, wir haben eine Klasse mit einer Methode, die wir über benutzerdefinierte Metriken überwachen möchten:
Klasse Auftrag def Betrag… Ende Ende
Wir können anfangen, das zu verfolgen Menge Methode wie folgt:
erfordern die Klasse 'new_relic / agent / method_tracer'. Order include :: NewRelic :: Agent :: MethodTracer def betrag… end add_method_tracer: Betrag, 'Benutzerdefiniert / Betrag' end
Der zweite Parameter zu add_method_tracer ist der Name, den diese benutzerdefinierte Metrik in der New Relic-Benutzeroberfläche erhält. Metriknamen sind durch Schrägstrich getrennte Zeichenfolgen, und alle benutzerdefinierten Metriken sollten mit 'Custom /' beginnen. Sie können Ihre benutzerdefinierte Metrik beispielsweise mit "Benutzerdefiniert /Menge Methode in Ihren Transaktionsverfolgungen in der New Relic-Benutzeroberfläche. Aber was ist wenn unser Menge Methode ist sehr komplex und wir möchten Teile davon überwachen, von denen wir vermuten, dass sie langsam sind? Mein Rat ist, dass Sie Ihre Methode umgestalten sollten - sie ist zu groß, aber wenn Sie das nicht können, können Sie zufälligen Code wie folgt instrumentieren:
class Order extend :: NewRelic :: Agent :: MethodTracer def betrag… self.class.trace_execution_scoped (['Custom / Quantity / complex_code']) do… komplexer Code… Ende… Ende
Der instrumentierte Teil der Methode wird jetzt separat in Ihren Transaktionsprotokollen angezeigt. Wenn Sie die Methode zuvor selbst instrumentiert haben, wird Ihre neue "innere" Metrik unter der vorherigen gruppiert.
Dies ist bei weitem die häufigste Methode, mit der Sie benutzerdefinierte Kennzahlen in Ihrem Code verwenden, aber schauen wir uns die anderen trotzdem an.
Häufig verwenden Sie möglicherweise eine Bibliothek, die, wie Sie vermuten, Ihre Anwendung verlangsamt. New Relic instrumentiert standardmäßig keinen zufälligen Edelstein für Sie. Was können Sie tun? Sie können den Edelstein mit dem oben beschriebenen Verfahren einfädeln und einige Instrumente hinzufügen. Eine noch einfachere Lösung ist jedoch die Verwendung von Initialisierern. Nehmen wir an, Sie verwenden die foobar Bibliothek, die eine Klasse hat Foo mit einer Methode Bar dass Sie vermuten, hat einen langsamen Code. Sie müssen lediglich einen Initialisierer erstellen foobar_instrumentation.rb, und füge folgendes hinzu:
erfordern 'new_relic / agent / method_tracer' Foo.class_eval muss Folgendes enthalten: NewRelic :: Agent :: MethodTracer add_method_tracer: Taktende
Wie Sie sehen, ist der Code dem oben beschriebenen sehr ähnlich. New Relic berechnet einen sinnvollen Namen für Ihre neue benutzerdefinierte Metrik, basierend auf dem Klassen- und Methodennamen, und Sie beginnen, ihn in Ihren Transaktionsablaufverfolgungen zu sehen. Verwenden Sie diese Option, um herauszufinden, ob die verdächtige Bibliothek tatsächlich dazu führt, dass Ihr Code schlecht funktioniert, aber lassen Sie diese Instrumentierung nicht dauerhaft aufrechterhalten. Sie spendet unnötige Initialisierungen in Ihrer Rails-App und verschmutzt Ihre New Relic-Benutzeroberfläche mit benutzerdefinierten Metriken, die Sie nicht wirklich permanent verfolgen müssen.
Ein Teil der Webanwendungen, der häufig vernachlässigt wird, sind Skripts. Um eine Präsentation zu formulieren, die ich kürzlich gemacht habe - sie ist immer noch Produktionscode und sollte als solcher behandelt werden. Sie möchten nicht, dass der Produktionscode schlecht funktioniert, insbesondere wenn Sie ihn kontinuierlich über cron-Jobs (oder eine ähnliche Methode, die in Ihrem System kein Hintergrundjob ist) ausführen. Daher können Sie mit New Relic herausfinden, ob Ihre Skripte sind langsam.
Sie können Ihren Skriptcode mit benutzerdefinierten Metriken wie oben beschrieben instrumentieren. Es wird nicht in Transaktionsprotokollen angezeigt, da es nicht Teil einer Transaktion ist. Sie können jedoch aus den erfassten Metriken ein benutzerdefiniertes Dashboard erstellen, das Ihnen eine Vorstellung davon vermitteln soll, ob Ihr Skript schlecht funktioniert.
Die andere Sache, die Sie tun können, ist, Ihr Skript als eine Art Hintergrundjob zu behandeln und es entsprechend zu instrumentieren (include NewRelic :: Agent :: Instrumentation :: ControllerInstrumentation und so weiter). Es wird mit anderen Hintergrundjobs in der Benutzeroberfläche zusammengefasst, aber Sie müssen sich keine Gedanken über benutzerdefinierte Dashboards machen.
Der einzige Nachteil bei Skripten ist folgender: New Relic sendet nur periodisch Daten über die Leitung. Bei einem einmaligen Skript, das schnell ausgeführt wird, müssen Sie sicherstellen, dass die erfassten Daten tatsächlich gesendet werden. Daher müssen Sie den New Relic-Agenten möglicherweise manuell herunterfahren. Eine gute Faustregel ist, den Agenten manuell am Anfang jedes Skripts zu starten und am Ende herunterzufahren:
erfordern 'newrelic_rpm' :: NewRelic :: Agent.manual_start… codez… :: NewRelic :: Agent.shutdown
Auf diese Weise müssen Sie sich nicht fragen, warum Ihre Daten nicht in der Benutzeroberfläche angezeigt werden.
Eine der interessantesten Eigenschaften von New Relic besteht darin, dass Sie die UI- und Datenaggregationsfunktionen für Metriken nutzen können, die nichts mit der Leistung zu tun haben (theoretisch). Beispielsweise möchten Sie vielleicht ein wenig Sicht darauf haben, wie oft sich Benutzer bei Ihrer Anwendung anmelden, wie oft der Umsatz abläuft oder wie viel Gesamteinnahmen die Benutzer beim Kauf zahlen. Dies sind mehr Geschäftskennzahlen als Leistungskennzahlen. Wenn es jedoch zu aufwendig ist, diese separat zu verfolgen, können Sie New Relic dazu verwenden.
Mit New Relic können Sie benutzerdefinierte Metriken direkt über zwei API-Aufrufe aufzeichnen:
record_metricincrement_metricSie können verwenden record_metric um jede Metrik zu verfolgen, die einen Betrag und increment_metric ist ziemlich selbsterklärend. So können wir beispielsweise Folgendes tun:
… Def buy (Betrag)… :: NewRelic :: Agent.record_metric ('Custom / purchase_amount', Betrag) :: NewRelic :: Agent.increment_metric ('Custom / purchase_count')… Ende… Sie können diese Metriken nur in der Benutzeroberfläche anzeigen, indem Sie einige benutzerdefinierte Dashboards erstellen. Ich muss erwähnen, dass dies eine etwas "kreative" Verwendung der New Relic-API wäre, da sie mit Blick auf Leistungsdaten konzipiert wurde, aber es ist sicherlich eine praktische Sache, wenn Sie wissen müssen, wann Sie ein schnelles Dashboard zusammen werfen müssen und nicht möchte eine Reihe zusätzlicher Infrastruktur einrichten.
Natürlich hat all diese Macht einen Preis. Wenn Sie zu viele benutzerdefinierte Messdaten erfassen, kann Ihre Anwendung verlangsamt werden. Es kann auch die Benutzeroberfläche von New Relic verlangsamen und die Interpretation der Daten erschweren, da New Relic ähnliche Metriken zu einer Zusammenfassung zusammenfasst. New Relic empfiehlt, die Anzahl der von Ihnen erfassten benutzerdefinierten Metriken unter 2000 zu halten. Ich habe festgestellt, dass benutzerdefinierte Metriken am besten regelmäßig verwendet werden. Instrumentieren Sie den Code, den Sie benötigen, verwenden Sie das Instrument, um das Problem zu lösen, das Sie haben, und entfernen Sie das Instrument. Auf diese Weise können Sie Ihre Leistungsprobleme lösen, und es wird unwahrscheinlich, dass die Anzahl der von Ihnen verwendeten benutzerdefinierten Metriken zu hoch wird.
Wir haben uns eingehend mit den inneren Elementen der newrelic_rpm gem und haben gelernt, New Relic über Code zu informieren, den Sie für eine Web-Transaktion halten. Wir haben untersucht, wie Transaktionen im laufenden Betrieb geändert werden können, wie Hintergrundjobs überwacht werden und in welchen Situationen es sinnvoll ist, benutzerdefinierte Metriken zu verwenden. Mit New Relic können Sie weit über die Funktionalität hinausgehen, die es standardmäßig bietet, und Sie können es jetzt viel besser ausnutzen. Es gibt jedoch immer mehr zu lernen, z. B. wie Sie aus den erfassten Messwerten benutzerdefinierte Dashboards erstellen oder die Infrastruktur mit Plugins überwachen. Wir werden diese Themen und noch mehr in den folgenden Artikeln behandeln. Schauen Sie sich also öfter mal um. Und wie immer, wenn Sie eine Frage haben, Ihre eigene New Relic-Geschichte teilen oder einfach nur Hallo sagen möchten, vergessen Sie nicht, einen Kommentar zu hinterlassen.
