Share
Odată ce începeți să săturați în jurul noului Relic, începeți să realizați cât de multe caracteristici interesante trebuie să vă ajute să monitorizați performanța și sănătatea aplicației dvs. A fost cu adevărat dificil să alegeți doar cinci lucruri despre care să vorbim, așa că, mai degrabă decât să ne concentrăm asupra caracteristicilor evidente, să ne uităm la unele dintre funcțiile mai puțin avansate pe care le oferă New Relic și cum le putem folosi în moduri interesante și uneori neortodoxe.
Când v-am părăsit ultima oară, am avut o aplicație de bază "Hello World" Rails (numită Noi Relic_rails1, trăiesc în ~ / project / tmp / New Relic). Vom continua să folosim această aplicație, să o extindem și să vedem dacă o putem folosi pentru a demonstra caracteristicile noului Relic pe care le vom analiza.
Acest conținut a fost comandat de New Relic și a fost scris și / sau editat de echipa Tuts +. Scopul nostru cu conținut sponsorizat este de a publica tutoriale relevante și obiective, studii de caz și interviuri inspirate care oferă cititorilor o valoare educațională autentică și ne permit să finanțăm crearea de conținut mai util.
Aceasta este o caracteristică New Relic, care de obicei nu face prima pagină a materialului de marketing. Nu este prea mult, dar dacă vă gândiți la asta, este mai important să vă asigurați că aplicația dvs. este de fapt disponibilă și accesibilă utilizatorilor dvs.?
În primul rând, când configurați monitorizarea disponibilității, aplicația dvs. primește un asterisc frumos pe tabloul de bord al aplicațiilor principale:
Este un memento vizibil frumos, astfel încât să puteți vedea ce aplicații au nevoie de monitorizarea disponibilității.
Să ne uităm acum la modul în care putem stabili monitorizarea disponibilității și la ce putem ieși din ea. În primul rând, trebuie să sariți în aplicația dvs. și apoi să intriți Setări-> Monitorizare disponibilitate. Veți vedea ceva de genul:
Trebuie să furnizați o adresă URL pe care doriți să o reintroduceți la New Relic, bifați caseta, salvați modificările și sunteți bine să mergeți. Noul Relic va începe să apară adresa URL la fiecare 30 de secunde. Dar distracția nu se oprește acolo. New Relic va ping adresa dvs. URL printr-o cerere HTTP HEAD (și va considera totul OK dacă primește un cod de răspuns 200), dar puteți furniza un șir de răspuns pe care doriți ca New Relic să caute în care caz va efectua o solicitare GET și examinați răspunsul pentru șirul pe care l-ați furnizat. Acest lucru poate fi foarte util dacă aveți o pagină personalizată "Verificare de sănătate" pe care doriți să o atingeți.
De asemenea, puteți seta notificarea prin e-mail dacă apare o perioadă de nefuncționare:
Acum, că monitorizați disponibilitatea, veți avea acces la un raport frumos, care vă va arăta vizual când a avut loc o perioadă de nefuncționare:
De fapt, multe dintre graficele dvs. (de exemplu, prezentarea generală a aplicației) vor avea această indicație vizuală:
Trebuie să recunoașteți că sunt niște funcții destul de frumoase pentru atât de puțin efort.
Poți, desigur, să dezactivezi și să reactivezi monitorizarea (prin intermediul noului Relic REST API) atunci când faci performanțe, pentru a te asigura că nu primești evenimente false.
Un alt efect secundar interesant este că, dacă desfășurați proiectul dvs. pentru animale de companie spre Heroku pe un singur dyno, puteți utiliza această funcție de ping pentru a împiedica somnul să dormi, ceea ce poate face site-ul dvs. enervant de lent dacă nu aveți o mulțime de trafic.
Dacă apar erori neașteptate în aplicația dvs., New Relic le va înregistra pentru dvs. și vă va oferi un grafic plăcut. Aplicația noastră "Hello World" a apărut admirabil pentru moment, așa că nu putem vedea nimic pe acest front. Dar, ne putem sparge intenționat aplicația și să vedem ce ne dă New Relic.
Să ne modificăm HelloController pentru a ridica o eroare la întâmplare aproximativ 50% din timp:
clasa HelloController < ApplicationController def index if rand(2) == 0 raise 'Random error' end end end
Vom face acum câteva sute de apeluri la aplicația noastră și vom vedea ce se întâmplă:
ab -n 300 -c 10 http://127.0.0.1:3000/
Noul nostru grafic de eroare Relic acum pare mult mai interesant:
Și putem să căutăm câteva detalii:
După cum puteți vedea, putem să sortăm erorile și să le filtrăm, precum și să analizăm separat erorile de la solicitările web și de la sarcinile de fundal. Acestea sunt câteva lucruri incredibil de puternice care vă ajută să diagnosticați și să remediați problemele cu aplicația dvs. De asemenea, puteți vedea, de asemenea, urmărirea stivei pentru fiecare eroare:
Există servicii special dedicate pentru a capta erori de la aplicația dvs., unele dintre cele mai cunoscute sunt Airbrake și Bugsnag. Acestea sunt servicii plătite utilizate de mai multe aplicații, dar funcționalitatea oferită de New Relic face ca aceste servicii să fie redundante. De fapt, dacă am putea trimite erori personalizate la New Relic (mai degrabă decât să-i lăsăm să captureze erori pe care nu le-am salvat), am putea face un caz convingător pentru a nu utiliza un serviciu separat de colectare a erorilor (și a salva niște bani și a scăpa de un extra bijuterie în acest proces).
În timp ce New Relic nu documentează nici un fel de a face acest lucru, putem merge mereu la sursă pentru a vedea dacă ceea ce vrem să facem este greu. Mi se pare că ar trebui să fie destul de banal pentru noi să trimitem erori personalizate la New Relic, așa că să încercăm. Vom modifica din nou acțiunea controlerului pentru a salva toate erorile și a trimite o eroare personalizată la New Relic:
Accentsconagua
clasa HelloController < ApplicationController def index if rand(2) == 0 raise 'Random error' end rescue New Relic::Agent.notice_error(StandardError.new("I caught and reraised an error")) end end După ce efectuăm câteva apeluri și așteptăm ca datele să vină, vedem următoarele:
A funcționat, eroarea noastră personalizată vine prin! Noul Relic poate funcționa cu siguranță ca serviciu de colectare a erorilor. Desigur, folosim o interfață privată, care nu este foarte plăcută, dar putem pune notice_error sunați în spatele unei fațade care va face lucrurile un pic mai ușor pentru noi în cazul în care se schimbă interfața.
O abordare mai bună ar putea fi să nu tratăm greșelile personalizate, cum ar fi erorile obișnuite, ci să creăm o metrică personalizată pentru a urmări și apoi a construi un tablou de bord personalizat pentru vizualizare. În acest fel, nu folosim nicio funcționalitate nedocumentată și vom obține totuși toate avantajele - strălucitoare!
Noua rețea Relic vă va urmări în mod normal tranzacțiile:
Veți putea vedea unde depune cererea dvs. cea mai mare parte a timpului (de exemplu, în controler, model, bază de date etc.). Cu toate acestea, New Relic nu va capta o urmă detaliată dacă operațiunea nu durează mai mult decât Appdex * 4 secunde. În mod normal, acest lucru este bine, dar cândva aveți tranzacții care sunt mult mai importante pentru aplicația dvs. sau pentru afacerea dvs. Poate că aceste tranzacții sunt extrem de mari sau se ocupă de evenimente importante precum plățile. Este suficient să spun că trebuie să vă asigurați că acest tip de tranzacție este întotdeauna extrem de performant.
Lucrul este însă că, atunci când o tranzacție este atât de importantă, probabil că a primit deja destulă dragoste de la dvs. și poate funcționa destul de bine. Să presupunem că aveți o tranzacție cu o viteză extrem de mare (apare de multe ori pe minut). Dacă această tranzacție are performanțe optime, totul este bine, dar dacă performanța s-ar degrada ușor, datorită volumului traficului, aceasta poate avea un efect negativ în detrimentul aplicației dvs. Ceea ce vrei este ceva de genul:
Acesta este exact ceea ce vă dau Tranzacțiile cheie cheie!
Înainte de a stabili o tranzacție cheie pentru aplicația noastră "Hello World", trebuie să creați o tranzacție mai interesantă, care de obicei va funcționa bine, dar uneori va funcționa oarecum prost. Vom construi abilitatea de a uita la modelele și modelele auto și pentru a obține o mașină specială pentru a încetini tranzacția în jos. În primul rând traseul:
Noua RelicRails1 :: Application.routes.draw primesc 'random_car', la: 'cars # show_random' root 'hello # index' end
Vrem să reușim să obținem o mașină aleatorie, acest lucru va avea loc la CarsController:
clasa CarsController < ApplicationController def show_random @car = Car.offset(rand(Car.count)).first if @car.make == 'Ford' sleep(2) end end end
Obținem o mașină aleatorie din baza de date și dacă mașina este "Ford", vom avea o tranzacție lentă pe mâini. Bineînțeles că avem nevoie de a Mașină model:
clasa Mașină < ActiveRecord::Base end
Va trebui să configuram baza de date pentru a folosi MySql în dezvoltare (am făcut acest lucru, dar vă puteți menține SQLite):
bază: & BASE adaptor: mysql2 codificare: utf8 gazdă: "localhost" nume utilizator: "root" max_connections: 10 timeout: 5000 dezvoltare: & DEV <<: *BASE database: "New Relic_rails1_development" sql_log_level: debug
Avem nevoie de o migrare pentru a crea o autoturisme masa:
mașini de clasă < ActiveRecord::Migration def change create_table :cars, force: true do |t| t.string :make t.string :model end end end
Și avem nevoie de niște date despre semințe pe care le vom pune în noi db / seeds.rb fişier:
Car.create (marca: 'Ford', model: 'Mondeo') Car.create (marca: 'Honda', model: 'Accord') Car.create (model: 'Audi'). creați (marca: 'Lamborghini', model: 'Murcielago') Car.create (marca: 'Toyota', model: 'Prius')
În cele din urmă ar trebui să avem o viziune autoturisme / show_random.html.erb:
Face: <%= @car.make %>
Model: <%= @car.model %>
De asemenea, va trebui să adăugați mysql2 bijuterie la Gemfile dacă ați plecat cu MySql. După aceasta, trebuie doar să creăm și să populam baza de date, să reluăm serverul și suntem bine să mergem:
bundle rake db: crează && rake db: migrează && rake db: șine de sârmă s
Va trebui să atingeți adresa URL, pentru a vă asigura că New Relic recunoaște existența acestei tranzacții:
curl localhost: 3000 / random_car
Suntem gata să monitorizăm această tranzacție ca o tranzacție-cheie. În primul rând, sariți în fila tranzacție:
Faceți clic pe butonul "Urmăriți o tranzacție cheie" și alegeți tranzacția nouă creată:
Putem oferi noului nostru nume cheie, alegeți Apdex T cu care suntem mulțumiți, precum și setarea unor alerte. Atunci când tranzacția noastră durează mai mult decât Apdex pe care l-am ales, New Relic va capta o urmă detaliată pe care o vom putea folosi pentru a afla unde provine problema de performanță. Să facem câteva apeluri împotriva noului nostru URL și să vedem ce date primim:
ab -n 300 -c 20 http://127.0.0.1:3000/random_car
Hmm, se pare că unele dintre tranzacțiile noastre sunt frustrante pentru utilizatorii noștri:
Să vedem dacă New Relic a capturat niște urme de tranzacții pentru noi:
Să ne uităm la una dintre aceste urme. A fost nevoie de aproximativ 2 secunde pentru a răspunde, dar numai 10 milisecunde folosesc CPU-ul:
Toate instrucțiunile SQL au fost rapide, astfel încât baza de date nu este problema:
Se pare că cele mai multe ori se petrec în acțiunea controlerului:
Să săpăm puțin. Se pare că SQL SELECT a fost rapid, a Car.find a fost de asemenea rapid. Apoi, vom pierde aproximativ 2 secunde, urmată de redarea unui șablon foarte rapid:
Noul Relic ne-a subliniat cu amabilitate unde am pierdut cele două secunde. Trebuie să ne uităm la codul nostru de comandă după o Car.find apel:
clasa CarsController < ApplicationController def show_random @car = Car.offset(rand(Car.count)).first if @car.make == 'Ford' sleep(2) end end end
Hmm, selecția inițială trebuie să fie Car.count apel, și Car.find, trebuie să se datoreze Car.offset apel. Întârzierea noastră mare este imediat după asta. Ahh uită-te la asta, o persoană proastă a pus o întârziere de 2 secunde în codul nostru atunci când modelul mașinii este "Ford". Asta ar explica de ce întârzierea noastră de 2 secunde se întâmplă doar o parte din timp. Mai bine o fac git vina în depozitul nostru pentru a afla cine a pus codul ăla oribil acolo! În privința a două gânduri, nu mai bine, pentru că ar putea spune că eu sunt eu.
De fiecare dată când efectuați apeluri către alte servicii din cadrul aplicației dvs. (de exemplu, o solicitare HTTP către un API, cum ar fi Twitter), New Relic va monitoriza aceste apeluri ca apeluri externe. Aceste zile, o aplicație serioasă se poate integra cu un număr de API-uri externe. Adesea, aceste servicii externe pot degrada semnificativ performanța aplicației dvs., mai ales dacă efectuați aceste apeluri în curs de desfășurare. Noul Relic poate arăta care dintre apelurile dvs. externe sunt cele mai lente, pe care le numiți cel mai mult și care răspund cel mai lent în medie. Puteți examina, de asemenea, performanța fiecăruia dintre serviciile externe pe care le utilizați individual. Hai sa incercam.
Vom crea un serviciu extern al nostru, construind o mică aplicație Sinatra. Mai întâi instalăm bijuteria:
gem instala sinatra
Creați un fișier nou pentru serviciul nostru:
atingeți external_service.rb
Și puneți codul de mai jos:
cer "sinatra" get '/ hello' do sleep_time = rand (2000) /1000.0 somn (sleep_time) "Hello World World # sleep_time!" Sfârșit
Acest serviciu va dormi pentru o perioadă aleatorie (între 0 și 2000 de milisecunde) și apoi va întoarce un răspuns "Hello" cu timpul la care a dormit. Acum trebuie doar să începem:
ruby external_service.rb
Înapoi în aplicația noastră Rails vom construi un nou controlor pentru a apela serviciul nostru extern. Vom folosi acest traseu:
New RelicRails1 :: Application.routes.draw nu ... obțineți 'external_call', la: 'external_calls # external_call' ... end
Controlorul nostru va apela serviciul nostru Sinatra prin HTTP:
necesită clasa ExternalCallsController "net / http" < ApplicationController def external_call url = URI.parse('http://localhost:4567/hello') external_request = Net::HTTP::Get.new(url.to_s) external_response = Net::HTTP.start(url.host, url.port) do |http| http.request(external_request) end @result = external_response.body end end Și avem nevoie de o vizualizare pentru afișarea rezultatelor:
<%= @result %>
Tot ce trebuie să facem acum este să faceți câteva apeluri către noul punct final:
ab -n 100 -c 10 http://127.0.0.1:3000/external_call
Să vedem ce a produs New Relic pentru noi.
Noua Relic ne-a adus într-adevăr apelul extern. Avem numărul total de apeluri pe minut pe care le facem către obiectivul extern. Iar suma totală care a fost cheltuită a răspuns la serviciul extern. Bineînțeles că graficul nostru arată puțin mai puțin, deoarece avem doar un serviciu extern, ceea ce înseamnă că nu avem nimic de comparat.
De asemenea, putem obține date mai detaliate despre apelul extern existent, precum și despre locul în care se face apel în aplicația noastră:
Putem vedea când au fost efectuate apelurile, viteza de transfer și timpul mediu de răspuns. Acest lucru poate părea simplu, dar când aveți o aplicație cu o mulțime de servicii externe, această caracteristică vă poate oferi o prezentare foarte frumoasă a modului în care aceste servicii externe sunt performante, precum și când și unde sunt utilizate. Acest lucru vă poate permite să luați deciziile privind cache-ul anumitor răspunsuri externe ale serviciului, dacă este posibil, sau chiar să abandonați anumite servicii externe dacă performanța lor nu este de până la zero. Și nu mai trebuie să argumentați aceste lucruri pe baza măsurătorilor intestinale și a măsurătorilor acasă, veți avea date dificile pentru a vă demonstra punctul de vedere pentru dvs..
Nu este nimic mai frustrant pentru un dezvoltator decât ca cererea dvs. să cadă din cauza unui vârf de trafic. Totul se desfășura fără probleme până când acei câțiva sute de utilizatori au venit și cererea dvs. a explodat. Ați avut un sentiment că s-ar putea întâmpla acest lucru, dar nu ar fi sigur - așteptările și atitudinea păreau a fi abordarea cea mai pragmatică. Ei bine, cu noua capacitate Relic și rapoarte de scalabilitate, nu mai trebuie să așteptați și să vedeți. Puteți afla imediat cât de bine scade aplicația dvs., puteți efectua teste de încărcare și puteți vedea instantaneu dacă aplicația poate gestiona sarcina. Puteți observa tendințele de răspuns ale solicitărilor de timp, pe măsură ce baza de utilizatori crește și anticipați când va trebui să adăugați o capacitate. Toate acestea sunt cu adevărat lucruri minunate.
În primul rând, să examinăm rapoartele privind capacitatea:
Hmm, acesta arată un vârf mare, dar altfel nimic. Ei bine, suntem în modul de dezvoltare, deci este de înțeles. Acel punct este atunci când am făcut o grămadă de cereri simultan cu puțin timp în urmă. După cum puteți vedea când am făcut acele solicitări concurente, am depășit situația noastră săracă singuratic Webrick. Dacă aceasta era o producție și această încărcătură era constantă, instanța noastră ar fi întotdeauna ocupată de 100%, ceea ce ar indica probabil că avem nevoie de un alt exemplu.
Raportul de analiză a instanței este ușor diferit:
În cazul nostru, nu reușim să reușim, dar în mod normal ne arată numărul de instanțe care se execută și numărul instanței de care avem nevoie pentru a face față încărcării dacă toate instanțele au fost ocupate 100%. Deci, dacă am fi rulat 10 instanțe și încărcarea instanței concurente a fost de 2, am putea ușor înjumătăți (sau chiar mai mult decât jumătate) numărul de instanțe care rulează și nu degrada performanța deloc. Pentru o aplicație mică, care rulează doar câteva cazuri, nu este o problemă mare, dar pentru o aplicație mare cu zeci și sute de cazuri, acest lucru se poate traduce într-o economie semnificativă a costurilor.
Și apoi există rapoartele de scalabilitate. Raportul privind timpul de răspuns este probabil cel mai interesant / important:
Încă o dată, graficul nostru este foarte distorsionat deoarece este o aplicație de dezvoltare pe care am jucat-o la întâmplare. Ideea cu acest raport este că, odată cu creșterea cantității de cereri pentru cererea dvs. (mai multe cereri pe minut), timpul de răspuns ar trebui să rămână aproape constant (adică performanța nu se degradează atunci când există mai mult trafic). Asta înseamnă că trebuie să vezi întotdeauna ceva care seamănă cu o linie plată aici. Dacă linia dvs. se înclină în sus în mod semnificativ, aplicația dvs. se luptă probabil să se ocupe de trafic și este posibil să fie nevoie să vă uitați la adăugarea unei capacități mai mari. Unde să adăugați capacitate este o altă întrebare în întregime (de exemplu, capacitatea bazei de date, mai multe servere etc.). Celelalte două rapoarte de scalabilitate vă pot ajuta să răspundeți la aceasta. Există raportul bazei de date:
Nu vă puteți aștepta ca baza dvs. de date să nu fie afectată de o sarcină mai mare, deci ceea ce ar trebui să vedeți aici este o linie care crește încet, pe măsură ce debitul cererii dvs. crește. Depinde de dvs. atunci când timpul de răspuns al bazei de date este considerat inacceptabil (adică influențează prea mult răspunsul aplicației), dar când decideți că răspunsurile la baza de date sunt prea lentă, știți că este timpul să adăugați capacitatea bazei de date. Celălalt raport este CPU:
Încă o dată nu vă puteți aștepta la o viteză mai mare de a nu afecta încărcarea CPU-ului dvs., ar trebui să vedeți o linie care se apropie încet de performanțe ridicate. Acest lucru, împreună cu rapoartele privind capacitatea despre care am vorbit mai devreme, vă permit să decideți când să adăugați mai multe procese / servere Rails pentru a vă asigura că performanțele dvs. rămân decente.
Dacă una sau toate aceste caracteristici au ridicat o sprânceană (sau două) pentru tine, vestea bună este că tocmai am zgâriat suprafața. Fiecare dintre aceste caracteristici merită mai mult decât merită un articol în profunzime. Dar, New Relic are, de asemenea, o serie de alte caracteristici care sunt potențial mai puternice, printre care: Real User Monitoring, Platforma New Relic, Profilul Thread, Pragurile de Alertă și Notificare și multe altele. Vom încerca să acoperim câteva sau chiar toate acestea în tutoriale ulterioare.
Deocamdată, încercați New Relic, deplasați un agent în limba dvs. preferată și vedeți dacă puteți descoperi un mod extraordinar de utilizare a unor funcționalități oferite de New Relic. Și dacă aveți câteva modalități inovatoare de a utiliza New Relic, asigurați-vă că îi spuneți tuturor, lăsând un comentariu.
