Share
När du först introduceras till New Relic är det lätt att bli överväldigad av alla funktioner. Men som med de flesta verktyg, som du sakta klättar in i inlärningskurvan och känner till funktionerna som finns ut ur lådan börjar du undra hur allt hänger ihop under huven och om det finns mer du kan göra med vad du har på hand.
Idag ska jag titta på hur New Relic faktiskt övervakar transaktioner och hur man kan koppla in i processen. Vi tar en snabb blick på stödet från New Relic för att övervaka bakgrundsjobb och vi kommer också att gräva in New Relic anpassade statistik, hur du skulle använda dem och de fördelar du får från att göra det. I slutet kommer du att få en djupare förståelse för hur New Relic fungerar och kunna utnyttja det mer fullständigt. Med andra ord kommer vi att ha en djupare kunskap om våra verktyg - något som varje utvecklare ska sträva efter.
Låt oss börja med att snabbt titta på hur New Relic faktiskt krokar in för att följa prestandan i din ansökan.
Sponsrat innehållDet här innehållet beställdes av New Relic och skrevs och / eller redigerades av Tuts + -laget. Vårt mål med sponsrat innehåll är att publicera relevanta och objektiva handledningar, fallstudier och inspirerande intervjuer som erbjuder genuint pedagogiskt värde till våra läsare och gör det möjligt för oss att finansiera skapandet av mer användbart innehåll.
Det kan tyckas lite som magi, du inkluderar en pärla i din Gemfile:
pärla "newrelic_rpm"
Och på något sätt övervakar New Relic all din kod. Självklart är det bara kod, så låt oss se hur New Relic faktiskt styr din app så att den kan börja övervaka den när agenten är äldre. Vi kommer att göra detta i samband med en Rails 4 app.
Det första stället att se är newrelic_rpm.rb, som har följande relevant kod i den:
... om Rails :: VERSION :: MAJOR.to_i> = 3 modul NewRelic klass Railtie < Rails::Railtie initializer "newrelic_rpm.start_plugin" do |app| NewRelic::Control.instance.init_plugin(:config => app.config) slutänden ände ...
Så en Railtie skapas när Rails-versionen är över tre, det blir en NewRelic :: Kontroll singleton instans (när den initialiseras) och samtal init_plugin. När NewRelic :: Kontroll Exempel skapas, det visar vilken ram som körs (Rails 4 i vårt fall) och laddar in någon relevant kod. vi kan se detta in new_relic / kontroll / class_methods # load_framework_class. De init_plugin metod som blir verkställd bor i new_relic / kontroll / instance_methods. Den intressanta koden här är:
... om Agent.config [: agent_enabled] &&! NewRelic :: Agent.instance.started? start_agent install_instrumentation load_samplers om inte Agent.config [: disable_samplers] ...
De install_instrumentation samtal är det viktiga. Genomförandet lever i new_relic / kontroll / instrumentering. Hoppa över kedjepanelbitarna, det här bestämmer vilka instrumentfiler det behöver ladda och kräver dem en efter en. I vårt fall kommer det att ladda filer under new_relic / agent / instrumentering / rails4. En av filerna här är action_controller.rb, När detta krävs krävs det så småningom följande kod via vissa metaprogrammerande magiker:
exekverar klassen ActionController :: Base inkluderar NewRelic :: Agent :: Instrumentation :: ControllerInstrumentation include NewRelic :: Agent :: Instrumentation :: Rails4 :: ActionController end NewRelic :: Agent :: Instrumentation :: ActionControllerSubscriber \ .subscribe (/ ^ process_action .action_controller $ /) slut
Och här kommer vi till kärnan av det: ActionController :: Base (från vilket alla dina controllers ärver) får ett par moduler som ingår i det, vars viktigaste är NewRelic :: Agent :: Instrumentation :: ControllerInstrumentation. Detta är början på hur New Relic börjar övervaka alla dina kontrolleråtgärder som "transaktioner". Det är naturligtvis en något förenklad syn och vi glänser över mycket detaljer, men det ger dig en uppfattning om hur New Relic övervakar din kod. Frågan är hur kan du använda denna information?
Det är högst osannolikt att du befinner dig i en situation där du använder ett webbramverk som New Relic inte redan har instrumentation för (i Ruby-världen), men låt oss säga att du gjorde det. Att veta vad vi vet nu kan vi enkelt manuellt reglera kontrollen av denna anpassade ram. Om vi har en kontroller så här:
klass CustomController def custom_action ... slutet slutet
Vi kan instrumentet så här:
klass CustomController inkluderar NewRelic :: Agent :: Instrumentation :: ControllerInstrumentation def custom_action ... slut add_transaction_tracer: custom_action end
Nu kommer din regleringsmetod spåras som en transaktion på samma sätt. Rails handlingar spåras. Självklart, om du har rullat ditt eget webbramverk som innehåller databashanteringskod, måste du göra extra arbete till instrumentet mycket av den koden, så att New Relic kan övervaka mer än bara kontrollerande åtgärder. Men den allmänna tanken är fortsatt bra.
Ovanstående mönster blir mer användbart när du vill att New Relic ska spåra bakgrundsjobb i din ansökan. Du är mycket mer benägna att ha rullat någon anpassad bakgrundshanteringskod än att du ska ha skrivit ditt eget webbramverk. Faktum är att vi just gjorde detta med Tuts + i början, även om vi nu flyttar till Sidekiq. Om du använder ett av de välkända bakgrundsjobbsystemen som Sidekiq, Resque eller Delayed Job, har New Relic redan inbyggd instrumentation, men om du rullade din egen är ovanstående mönster allt du behöver för att övervaka dina uppgifter.
Till exempel var våra anpassade Tuts + bakgrundsjobb regelbundna rubinklasser som svarade på Kör metod, så allt vi behöver göra är detta:
klass SomeBackgroundJob inkluderar NewRelic :: Agent :: Instrumentation :: ControllerInstrumentation def execute ... slutet add_transaction_tracer: custom_action, category:: task end
Den sista biten, Kategori:: Uppgift, är att se till att New Relic inte spårar den som en webbtransaktion, men behandlar den istället som en bakgrundsuppgift och får den att visas under fliken Bakgrundsuppgifter i New Relic-gränssnittet. Om vi skapar en basklass för alla våra jobb kan vi placera instrumentet där och barnklasser kommer att arva det, så vi behöver inte oroa oss för att göra ovanstående i varje jobbklass.
Intressant nog, även de webbtransaktioner som New Relic automatiskt övervakar inte är heliga. Du kan till exempel lägga till några anpassade parametrar som ska skickas till New Relic för transaktionen som för närvarande exekveras (om du har aktiverat infångningsparametrar).
Du kan göra detta när som helst under transaktionen. Allt du behöver göra är att ringa :: NewRelic :: Agent.add_custom_parameters (: key => 'value') när som helst och parametrarna du skickar in kommer att läggas till parameterns data som du ser inuti New Relic. Om vi till exempel hade en kontroller som såg ut så här:
klass HelloController < ApplicationController def index ::NewRelic::Agent.add_custom_parameters(:hello => "världens") slutet
Långsamma transaktioner skulle ge oss följande:
Det här är inte allt vi kan göra. Vi kan segmentera en transaktion medan den körs genom att byta namn på den. Låt oss säga att vi vill behandla en transaktion som speciell när den utförs av en viss användare. Du kan göra något så här:
Accentsconagua
klass 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 Nu kommer denna transaktion att behandlas som en separat transaktion i New Relic-gränssnittet:
Till och med standard New Relic instrumentation har lite utrymme för anpassning, men ibland, precis som Captain Kirk, behöver du bara mer kraft. Det är här anpassade mätvärden kommer in.
Tillbaka på dagen skulle du ha använt anpassade mätvärden för att övervaka saker som extern tjänstekommunikation och användning av olika vanliga verktyg som Redis. Idag har New Relic bättre sätt att övervaka de sakerna, så vad behöver vi anpassade statistik för? Jag har hittat anpassade statistik för att vara användbar i fyra situationer:
Låt oss ta en snabb titt på var och en av dem.
New Relic är ganska bra att bryta ner prestandan för dina olika applikationsmetoder i ett transaktionsspår, men ibland ser du något som detta i ett spår:
Det verkar som om det finns programkod som New Relic inte kunde vara av någon anledning. Vad vi kan göra är att hjälpa New Relic (och oss) med några anpassade mätvärden. Vi måste ta reda på vilken metod New Relic hade problem med att övervaka och koppla in några anpassade mätvärden för att spåra hur lång tid den här metoden tog för att utföra. Detta kommer då att visas i alla efterföljande spår. Låt oss säga att vi har en klass med en metod som vi vill övervaka via anpassade statistik:
klass Beställningsbelopp ... slutänden
Vi kan börja spåra belopp metod som så:
kräva 'new_relic / agent / method_tracer'-klassen Beställa inkluderar :: NewRelic :: Agent :: MethodTracer def amount ... än add_method_tracer: mängd,' Custom / amount 'slutet
Den andra parametern till add_method_tracer är namnet som den här anpassade metriska kommer att få i New Relic-gränssnittet. Metriska namn är slash separerade strängar och alla anpassade parametrar bör börja med 'Custom /'. Du kan till exempel namnge din anpassade statistik som "Anpassad /belopp metod i dina transaktionsspår, i New Relic-användargränssnittet. Men, vad om vår belopp Metoden är mycket komplex och vi vill övervaka delar av den som vi misstänker är långsamma? Mitt råd är att du bör refactor din metod-det är för stort, men om du inte kan göra det kan du instrument slumpmässig kod som så:
klass Beställa förlänga :: NewRelic :: Agent :: MethodTracer def amount ... self.class.trace_execution_scoped (['Custom / amount / complex_code']) gör ... komplex kod ... slutet ... slutet
Nu redovisas den instrumenterade delen av metoden separat i dina transaktionsspår. Om du tidigare har instrumentat själva metoden grupperas din nya "inre" metriska under den föregående.
Det här är den vanligaste sätten att du kommer att sluta använda anpassade statistik i din kod, men låt oss titta på de andra ändå.
Ofta kan du använda ett bibliotek som du misstänker saktar ner din ansökan. New Relic kommer inte som standard någon slumpmässig pärla för dig, så vad kan du göra? Du kan gaffla pärlan och lägga till några instrumentinstrument med den metod vi såg ovan, men en ännu enklare lösning finns - använd initialisatorer. Låt oss säga att du använder Foo bar bibliotek som har en klass foo med en metod bar som du misstänker har lite långsam kod i den. Allt du behöver göra är att skapa en initializer foobar_instrumentation.rb, och lägg följande i det:
kräva 'new_relic / agent / method_tracer' Foo.class_eval inkluderar :: NewRelic :: Agent :: MethodTracer add_method_tracer: bar end
Som du kan se är koden mycket lik vad vi hade ovan kommer New Relic att utarbeta ett förnuftigt namn för din nya anpassade metrik baserat på klass- och metodnamn och du kommer att börja se den i dina transaktionsspår. Använd det här för att ta reda på om det misstänkta biblioteket verkligen gör din kod mycket dålig, men håll inte den här instrumentationen permanent. Det spammar onödiga initialisatorer i din Applikation av Rails och förorenar ditt New Relic-gränssnitt med anpassade mätvärden som du inte behöver spåra permanent.
En del av webbapplikationer som ofta försummas är skript. För att parafrasera en presentation som jag nyligen gjorde - de är fortfarande produktionskod och bör behandlas som sådana. Du vill inte att produktionskoden ska fungera illa, speciellt om du utför det kontinuerligt via cron-jobb (eller en liknande metod som inte är ett bakgrundsarbete i ditt system), så vi kan använda New Relic för att ta reda på om dina skript är långsamma.
Du kan ställa in din skriptkod med hjälp av anpassade mätvärden som beskrivs ovan. Det kommer inte att dyka upp i transaktionsspår eftersom det inte kommer att ingå i en transaktion. Vad du dock kan göra är att skapa en anpassad instrumentpanel från de mätvärden du samlar in, vilket skulle ge dig en uppfattning om ditt skript fungerar dåligt.
Det andra du kan göra är att behandla ditt manus som en typ av bakgrundsarbete och instrumentera det därmed (inkludera NewRelic :: Agent :: Instrumentation :: ControllerInstrumentation och så vidare). Det kommer att klumpas ihop med andra bakgrundsjobb i användargränssnittet, men du behöver inte oroa dig för anpassade instrumentpaneler.
Det enda tillvägagångssättet med skript är detta: New Relic skickar bara data över ledningen periodiskt. Med ett enstaka skript som kör snabbt måste du se till att de samlade uppgifterna faktiskt skickas, så du kan behöva stänga av New Relic-agenten manuellt. En bra tumregel är att manuellt starta agenten i början av varje manus och stänga av det i slutet:
kräver 'newrelic_rpm' :: NewRelic :: Agent.manual_start ... codez ... :: NewRelic :: Agent.shutdown
På så sätt behöver du aldrig undra varför dina uppgifter inte visas i användargränssnittet.
En av de intressanta sakerna om New Relic är att det låter dig dra nytta av dess användargränssnitt och dataaggregationsanläggningar för mätvärden som inte har något att göra med prestanda (i teorin). Du kanske till exempel vill ha viss synlighet på hur ofta användarna registrerar sig för din ansökan, försäljningsfrekvensen eller det totala antalet användare som betalar när de gör inköp. Det här är fler affärsmätningar än prestanda, men om det är för mycket problem att spåra dessa separat kan du använda New Relic att göra det.
Med New Relic kan du spela in anpassade mätvärden direkt via två API-samtal:
record_metricincrement_metricDu kan använda record_metric för att spåra alla mätvärden som har ett belopp och increment_metric är ganska självförklarande. Så vi kan till exempel göra det här:
... inköp (mängd) ... :: NewRelic :: Agent.record_metric ('Custom / buy_amount', mängd) :: NewRelic :: Agent.increment_metric ('Custom / purchase_count') ... än ... Det enda sättet för dig att se dessa mätvärden i användargränssnittet är att skapa några anpassade instrumentpaneler. Jag måste nämna att detta skulle vara en något "kreativ" användning av New Relic API, eftersom den är utformad med prestandadata i åtanke, men det är verkligen en praktisk sak att veta när du behöver kasta en snabb instrumentbräda tillsammans och inte vill skapa en massa extra infrastruktur.
Naturligtvis har all denna kraft en kostnad. Om du samlar för många anpassade statistik kan det börja att sakta ner din ansökan. Det kan också sakta ner New Relic-gränssnittet och göra det svårt att tolka data eftersom New Relic kommer att kollapsa liknande mätvärden i en sammanfattande en. New Relic rekommenderar att du håller antalet anpassade statistik som du samlar in under 2000. Jag har funnit att anpassade mätvärden används bäst regelbundet. Instrumentet koden du behöver, använd instrumentationen för att lösa problemet du har och ta sedan bort instrumentet. På så sätt kan du lösa dina prestandafrågor och antalet anpassade mätvärden du brukar är osannolikt att växa för högt.
Vi har grävit in i internals av newrelic_rpm pärla och har lärt sig att berätta för New Relic om kod som du anser vara en webbtransaktion. Vi har tittat på hur man ändrar transaktioner i flygningen, hur man övervakar bakgrundsjobb och de olika situationer där det är vettigt att använda anpassade mätvärden. Det finns mycket du kan göra med New Relic utöver den funktionalitet som den ger ut ur lådan och du är nu mycket mer kunna utnyttja den till sin fulla potential. Men det finns alltid mer att lära sig, till exempel hur man bygger egna instrumentpaneler ur de mätvärden du registrerar, eller hur man övervakar infrastruktur med plugins. Vi kommer att täcka dessa ämnen och mer i efterföljande artiklar, så se till att kolla tillbaka ofta. Och som alltid om du har en fråga, vill du dela din egen New Relic-historia eller bara vill säga hej, glöm inte att lämna en kommentar.
