Share
Wanneer u voor het eerst kennismaakt met New Relic, kunt u gemakkelijk overweldigd worden door alle functies. Maar zoals met de meeste gereedschappen, terwijl je langzaam de leercurve beklimt en bekend raakt met de functies die uit de doos komen, begin je je af te vragen hoe alles onder de motorkap hangt en of er meer is dat je kunt doen met wat je hebt bij hand-.
Vandaag zal ik bekijken hoe New Relic transacties daadwerkelijk bewaakt en hoe je kunt inhaken op het proces. We zullen snel een blik werpen op de ondersteuning door New Relic voor het monitoren van achtergrondtaken en we zullen ook ingaan op aangepaste maatstaven voor New Relic, hoe je ze zou gebruiken en de voordelen die je daarbij krijgt. Op het einde zul je een dieper inzicht hebben in hoe New Relic werkt en in staat zijn om het vollediger te gebruiken. Met andere woorden, we zullen een diepere kennis hebben van onze tools - iets waar elke ontwikkelaar naar zou moeten streven.
Laten we beginnen met een korte blik op hoe New Relic echt inhaakt om de prestaties van uw applicatie bij te houden.
Gesponsorde inhoudDeze inhoud is gemaakt in opdracht van New Relic en is geschreven en / of bewerkt door het Tuts + -team. Ons doel met gesponsorde inhoud is het publiceren van relevante en objectieve zelfstudies, casestudy's en inspirerende interviews die echte educatieve waarde bieden aan onze lezers en ons in staat stellen om het creëren van bruikbare inhoud te financieren..
Het lijkt een beetje op magie, je neemt een edelsteen in je op Gemfile:
gem 'newrelic_rpm'
En op de een of andere manier bewaakt New Relic al je code. Natuurlijk is het gewoon code, dus laten we eens kijken hoe New Relic uw app daadwerkelijk in de praktijk brengt, zodat deze kan beginnen met het monitoren wanneer het juweeltje van de agent vereist is. We doen dit in het kader van een Rails 4-app.
De eerste plaats om te kijken is newrelic_rpm.rb, met daarin de volgende relevante code:
... if Rails :: VERSION :: MAJOR.to_i> = 3 module NewRelic klasse Railtie < Rails::Railtie initializer "newrelic_rpm.start_plugin" do |app| NewRelic::Control.instance.init_plugin(:config => app.config) end end end else ...
Dus een Railtie wordt gemaakt wanneer de Rails-versie boven de drie is, dit krijgt een NewRelic :: Controle singleton-instantie (wanneer deze is geïnitialiseerd) en oproepen init_plugin. Wanneer de NewRelic :: Controle instance wordt aangemaakt, wordt uitgezocht welk framework wordt uitgevoerd (Rails 4 in ons geval) en laadt een aantal relevante code; we kunnen dit zien new_relic / control / class_methods # load_framework_class. De init_plugin methode die wordt uitgevoerd woont in new_relic / control / instance_methods. De interessante code hier is:
... als Agent.config [: agent_enabled] &&! NewRelic :: Agent.instance.started? start_agent install_instrumentation load_samplers, tenzij Agent.config [: disable_samplers] ...
De install_instrumentation gesprek is de belangrijkste. De implementatie leeft in new_relic / control / instrumentatie. Over de boilerplate-bits springt het uit, welke instrumentatiebestanden het moet laden en ze dan één voor één nodig heeft. In ons geval zal het bestanden laden onder new_relic / middel / instrumentatie / rails4. Een van de bestanden hier is action_controller.rb, wanneer dit wordt vereist, voert het uiteindelijk de volgende code uit via een magische metaprogrammering:
voert klasse ActionController uit :: Base include NewRelic :: Agent :: Instrumentation :: ControllerInstrumentation include NewRelic :: Agent :: Instrumentation :: Rails4 :: ActionController end NewRelic :: Agent :: Instrumentatie :: ActionControllerSubscriber \ .subscribe (/ ^ process_action .action_controller $ /) einde
En hier komen we tot de essentie: ActionController :: Base (waarvan al uw controllers erven) krijgt een aantal modules daarin, waarvan de belangrijkste is NewRelic :: Agent :: Instrumentatie :: ControllerInstrumentation. Dit is het begin van hoe New Relic al uw controlleracties als 'transacties' begint te bewaken. Natuurlijk is het een enigszins vereenvoudigde weergave en we geven veel details weg, maar het geeft je een idee van hoe New Relic je code bewaakt. De vraag is, hoe kun je deze informatie gebruiken?
Je zult je hoogstwaarschijnlijk niet in een situatie bevinden waarin je een webraamwerk gebruikt waar New Relic nog geen instrumentarium voor heeft (in de Ruby-wereld), maar laten we zeggen dat je het hebt gedaan. Als we weten wat we nu weten, kunnen we de acties van de controller van dit aangepaste framework eenvoudig handmatig aanpassen. Als we een controller als deze hebben:
klasse CustomController def custom_action ... end end
We kunnen het als volgt bewerken:
class CustomController include NewRelic :: Agent :: Instrumentatie :: ControllerInstrumentation def custom_action ... end add_transaction_tracer: custom_action end
Uw controlemechanismemethode wordt nu als een transactie gevolgd op dezelfde manier als Rails-acties worden bijgehouden. Als u uw eigen webraamwerk met databasebehandelingscode hebt gerold, moet u natuurlijk extra werk verrichten om een groot deel van die code te bewerken, zodat New Relic meer dan alleen controlleracties kan controleren. Maar het algemene idee blijft goed.
Het bovenstaande patroon wordt nuttiger wanneer u wilt dat New Relic achtergrondtaken in uw toepassing bijhoudt. Het is veel waarschijnlijker dat u een aangepaste achtergrondtaakverwerkingscode hebt gerold dan dat u uw eigen webraamwerk hebt geschreven. Eigenlijk deden we dit aanvankelijk alleen met Tuts +, hoewel we nu naar Sidekiq migreren. Als je een van de bekende achtergrondtakensystemen zoals Sidekiq, Resque of Delayed Job gebruikt, is er in New Relic al instrumentatie ingebouwd, maar als je er zelf een hebt gemaakt, is het bovenstaande patroon alles wat je nodig hebt om je taken te controleren.
Onze aangepaste Tuts + achtergrondtaken waren bijvoorbeeld gewone ruby-klassen die reageerden op de uitvoeren methode, dus alles wat we moeten doen is dit:
class SomeBackgroundJob include NewRelic :: Agent :: Instrumentatie :: ControllerInstrumentation def execute ... end add_transaction_tracer: custom_action, category:: task end
Het laatste beetje, categorie:: taak, is ervoor te zorgen dat New Relic het niet bijhoudt als een webtransactie, maar het in plaats daarvan behandelt als een achtergrondtaak en deze laat verschijnen op het tabblad achtergrondtaken in de New Relic UI. Als we een basisklasse maken voor al onze banen, kunnen we de instrumenten daar plaatsen en de kinderlessen zullen deze erven, dus we hoeven ons geen zorgen te maken over het bovenstaande in elke functieklasse.
Interessant genoeg zijn zelfs de webtransacties die New Relic automatisch controleert niet heilig. U kunt bijvoorbeeld enkele aangepaste parameters toevoegen die naar New Relic moeten worden verzonden voor de transactie die momenteel wordt uitgevoerd (als u de vastleggingsparameters hebt ingeschakeld).
U kunt dit op elk moment tijdens de transactie doen. Het enige dat u hoeft te doen is bellen :: NewRelic :: Agent.add_custom_parameters (: key => 'value') op elk moment en de parameters die u invoert, worden toegevoegd aan de parametergegevens die u ziet in New Relic. Als we bijvoorbeeld een controller hadden die er zo uitzag:
klas HelloController < ApplicationController def index ::NewRelic::Agent.add_custom_parameters(:hello => 'wereld') einde
Trage transacties zouden ons het volgende geven:
Dit is niet alles wat we kunnen doen. We kunnen een transactie segmenteren terwijl deze wordt uitgevoerd door de naam ervan te wijzigen. Laten we zeggen dat we een transactie als speciaal willen beschouwen wanneer deze door een bepaalde gebruiker wordt uitgevoerd. U kunt zoiets als dit doen:
Accentsconagua
klas 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 wordt deze transactie behandeld als een afzonderlijke transactie in de gebruikersinterface van New Relic:
Zelfs standaard New Relic-instrumenten hebben wat ruimte voor maatwerk, maar soms, net als Captain Kirk, heb je gewoon meer kracht nodig. Dit is waar aangepaste statistieken binnenkomen.
Vroeger had u aangepaste statistieken gebruikt om zaken als externe servicecommunicatie en het gebruik van verschillende algemene hulpmiddelen zoals Redis te controleren. Tegenwoordig heeft New Relic betere manieren om dat soort dingen te bewaken, dus waar hebben we aangepaste statistieken voor nodig? Ik heb aangepaste statistieken gevonden die nuttig zijn in vier situaties:
Laten we ze snel bekijken.
New Relic is best goed in het afbreken van de prestaties van uw verschillende applicatiemethoden in een transactietracering, maar soms ziet u zoiets als een spoor:
Het lijkt erop dat er toepassingscode is die New Relic om de een of andere reden niet kon instrumenteren. Wat we kunnen doen, is New Relic (en onszelf) helpen met enkele aangepaste statistieken. We moeten uitzoeken welke methode New Relic problemen had met het monitoren en een aantal aangepaste statistieken inhaken om bij te houden hoe lang deze methode duurde om uit te voeren. Dit verschijnt dan in alle volgende sporen. Laten we zeggen dat we een klasse hebben met een methode die we willen monitoren via aangepaste statistieken:
klasse Order def hoeveelheid ... einde einde
We kunnen beginnen met het volgen van de bedrag methode zoals zo:
vereisen 'new_relic / agent / method_tracer' class Bestelling include :: NewRelic :: Agent :: MethodTracer def hoeveelheid ... end add_method_tracer: aantal, 'Aangepast / aantal' einde
De tweede parameter voor add_method_tracer is de naam die deze aangepaste statistiek in de gebruikersinterface van New Relic krijgt. Metrische namen zijn gescheiden door streepjes gescheiden en alle aangepaste statistieken moeten beginnen met 'Aangepast /'. U kunt bijvoorbeeld uw aangepaste statistiek een naam geven als 'Aangepast /bedrag methode in uw transactiesporen, in de gebruikersinterface van New Relic. Maar wat als onze bedrag methode is zeer complex en we willen delen ervan controleren waarvan we vermoeden dat ze traag zijn? Mijn advies is dat je je methode moet refactoren - hij is te groot, maar als je dat niet kunt, kun je willekeurige code gebruiken zoals:
class Order extend :: NewRelic :: Agent :: MethodTracer def amount ... self.class.trace_execution_scoped (['Custom / amount / complex_code']) do ... complexe code ... einde ... end-end
Nu zal het geïnstrumenteerde deel van de methode afzonderlijk worden vermeld in uw transactiesporen. Als u eerder de methode zelf hebt gebruikt, wordt uw nieuwe 'innerlijke' metriek gegroepeerd onder de vorige.
Dit is veruit de meest gebruikte manier om aangepaste statistieken in uw code te gebruiken, maar laten we de andere toch bekijken.
Vaak gebruikt u mogelijk een bibliotheek waarvan u vermoedt dat deze uw toepassing vertraagt. Nieuwe Relic zal standaard geen willekeurige edelsteen voor je aansturen, dus wat kun je doen? Je kunt het juweel afvuren en wat instrumentatie toevoegen met behulp van de methode die we hierboven hebben gezien, maar er is een nog eenvoudiger oplossing: gebruik initializers. Laten we zeggen dat je de foobar bibliotheek die een klasse heeft Foo met een methode bar waarvan je vermoedt dat het een trage code bevat. Het enige wat u hoeft te doen is een initialisatie maken foobar_instrumentation.rb, en leg het volgende erin:
vereisen 'new_relic / agent / method_tracer' Foo.class_eval bevatten: NewRelic :: Agent :: MethodTracer add_method_tracer: bar end
Zoals u kunt zien is de code erg vergelijkbaar met wat we hierboven hadden, zal New Relic een logische naam voor uw nieuwe aangepaste statistiek berekenen op basis van de naam van de klasse en de methode en u zult deze in uw transactiesporen zien. Gebruik dit om uit te vinden of die verdachte bibliotheek je code echt slecht doet, maar houd deze instrumenten niet permanent bij de hand. Het blokkeert onnodige initializers in uw Rails-app en vervuilt uw New Relic UI met aangepaste statistieken die u niet echt permanent hoeft te volgen.
Een deel van webtoepassingen dat vaak wordt verwaarloosd, zijn scripts. Om een presentatie te parafraseren die ik recent heb gedaan - het is nog steeds productiecode en moet als zodanig worden behandeld. Je wilt niet dat de productiecode slecht presteert, vooral als je het continu uitvoert via cron-taken (of een vergelijkbare methode die geen achtergrondtaak is in je systeem), dus we kunnen New Relic gebruiken om te achterhalen of je scripts zijn traag.
U kunt uw scriptcode bewerken met behulp van aangepaste statistieken zoals hierboven beschreven. Het wordt niet weergegeven in transactiesporen omdat het geen deel uitmaakt van een transactie. Wat u echter wel kunt doen, is een aangepast dashboard maken op basis van de statistieken die u verzamelt. Dit zou u een idee moeten geven als uw script slecht presteert.
Het andere dat u kunt doen, is uw script als een soort achtergrondtaak behandelen en dienovereenkomstig inpassen (opnemen NewRelic :: Agent :: Instrumentatie :: ControllerInstrumentation enzovoorts). Het wordt samen met andere achtergrondtaken in de gebruikersinterface gegroepeerd, maar u hoeft zich geen zorgen te maken over aangepaste dashboards.
Het enige voorbehoud met scripts is dit: New Relic verzendt alleen periodiek gegevens over de draad. Met een eenmalig script dat snel wordt uitgevoerd, moet u ervoor zorgen dat de verzamelde gegevens daadwerkelijk worden verzonden, dus u moet mogelijk de New Relic-agent handmatig afsluiten. Een goede vuistregel is om de agent aan het begin van elk script handmatig te starten en aan het einde af te sluiten:
vereisen 'newrelic_rpm' :: NewRelic :: Agent.manual_start ... codez ... :: NewRelic :: Agent.shutdown
Op deze manier hoeft u zich nooit af te vragen waarom uw gegevens niet in de gebruikersinterface verschijnen.
Een van de interessante dingen over New Relic is dat je gebruik kunt maken van de UI en datagroepfaciliteiten voor metrieken die niets met prestaties te maken hebben (in theorie). U wilt bijvoorbeeld enige zichtbaarheid hebben over hoe vaak gebruikers zich aanmelden voor uw app, de frequentie van verkopen of het totale bedrag dat gebruikers betalen bij het doen van aankopen. Dit zijn meer bedrijfsstatistieken dan prestatiemetingen, maar als het teveel moeite is om deze afzonderlijk te volgen, kunt u New Relic gebruiken om dit te doen.
Met New Relic kunt u eigen statistieken rechtstreeks opnemen via twee API-aanroepen:
record_metricincrement_metricJe kunt gebruiken record_metric om elke statistiek met een bedrag en te volgen increment_metric is vrij vanzelfsprekend. Dus we kunnen dit bijvoorbeeld doen:
... def purchase (amount) ... :: NewRelic :: Agent.record_metric ('Aangepast / purchase_amount', aantal) :: NewRelic :: Agent.increment_metric ('Custom / purchase_count') ... end ... De enige manier om deze statistieken in de gebruikersinterface te zien, is om een aantal aangepaste dashboards te maken. Ik moet vermelden dat dit een ietwat "creatief" gebruik van de New Relic API zou zijn, omdat het ontworpen is met prestatiegegevens in het achterhoofd, maar het is zeker handig om te weten wanneer je een snel dashboard samen moet gooien en niet wil een heleboel extra infrastructuur opzetten.
Natuurlijk heeft al deze kracht een prijs. Als u te veel aangepaste statistieken verzamelt, kan dit uw toepassing trager maken. Het kan ook de New Relic UI vertragen en het moeilijk maken om de gegevens te interpreteren, aangezien New Relic vergelijkbare statistieken samenvat in een samenvatting. New Relic beveelt aan om het aantal aangepaste statistieken dat u onder 2000 verzamelt, te behouden. Ik heb geconstateerd dat aangepaste statistieken het best periodiek kunnen worden gebruikt. Instrumenteer de code die u nodig hebt, gebruik de instrumentatie om het probleem dat u ondervindt op te lossen en verwijder vervolgens de instrumenten. Op deze manier kunt u uw prestatieproblemen oplossen en wordt het aantal aangepaste statistieken dat u gebruikt waarschijnlijk niet te hoog.
We hebben de binnenkant van de newrelic_rpm gem en hebben geleerd om New Relic te vertellen over code die u als een webtransactie beschouwt. We hebben gekeken hoe u transacties on the fly kunt wijzigen, achtergrondtaken kunt bewaken en de verschillende situaties waarin het zinvol is om aangepaste statistieken te gebruiken. Met New Relic kun je veel meer doen dan alleen de functionaliteit die het uit de doos biedt en je bent nu veel beter in staat om het volledig te benutten. Maar er is altijd meer te leren, zoals hoe u aangepaste dashboards kunt bouwen uit de statistieken die u vastlegt, of hoe u de infrastructuur kunt monitoren met plug-ins. We behandelen deze onderwerpen en meer in volgende artikelen, dus kom regelmatig terug. En zoals altijd als je een vraag hebt, je eigen New Relic-verhaal wilt delen of gewoon hoi wilt zeggen, vergeet dan niet om een reactie achter te laten.
