.NET कोर में DiagnosticSource का उपयोग करना: सिद्धांत

DiagnosticSource API का एक सरल लेकिन बहुत उपयोगी सेट है (NuGet पैकेज सिस्टम में उपलब्ध है ।iiostostics.DiagnosticSource), जो एक तरफ, विभिन्न पुस्तकालयों को उनके काम के बारे में नामांकित घटनाओं को भेजने की अनुमति देता है, और दूसरी ओर, इन घटनाओं और प्रक्रिया के लिए आवेदन करने की अनुमति देता है। उन्हें।

इस तरह की प्रत्येक घटना में अतिरिक्त जानकारी (पेलोड) होती है, और चूंकि घटनाओं को भेजने के रूप में एक ही प्रक्रिया में संसाधित किया जाता है, इस जानकारी में क्रमांकन / deserialization की आवश्यकता के बिना लगभग कोई भी ऑब्जेक्ट हो सकते हैं।

DiagnosticSource पहले से ही AspNetCore, EntityFrameworkCore, HttpClient और SqlClient में उपयोग किया जाता है, जो वास्तव में डेवलपर्स को इनकमिंग / आउटगोइंग http अनुरोधों, डेटाबेस अनुरोधों, एक्सेस ऑब्जेक्ट्स जैसे DbCommand , DbCommand , DbCommand , HttpRequestMessage को इंटरसेप्ट करने की सुविधा देता है। यदि आवश्यक हो तो वस्तुओं।

मैंने अपनी कहानी को DiagnosticSource के बारे में दो लेखों में विभाजित करने का निर्णय लिया। इस लेख में, हम एक सरल उदाहरण के साथ तंत्र के संचालन के सिद्धांत का विश्लेषण करेंगे, और अगले I में उन घटनाओं के बारे में बात करेंगे जो .NET में मौजूद हैं जिन्हें इसका उपयोग करके संसाधित किया जा सकता है और OZON.ru में इसके उपयोग के कुछ उदाहरण दिखा सकते हैं।

उदाहरण

DiagnosticSource कैसे काम करता है, इसे बेहतर ढंग से समझने के लिए, डेटाबेस प्रश्नों को इंटरसेप्ट करने के छोटे उदाहरण पर विचार करें। कल्पना करें कि हमारे पास एक सरल कंसोल एप्लिकेशन है जो डेटाबेस के लिए अनुरोध करता है और कंसोल में परिणाम प्रदर्शित करता है।

 public static class Program { public const string ConnectionString = @"Data Source=localhost;Initial Catalog=master;User ID=sa;Password=Password12!;"; public static async Task Main() { var answer = await GetAnswerAsync(); Console.WriteLine(answer); } public static async Task<int> GetAnswerAsync() { using (var connection = new SqlConnection(ConnectionString)) { // using Dapper return await connection.QuerySingleAsync<int>("SELECT 42;"); } } } 

सादगी के लिए, मैंने एक डॉकटर कंटेनर में SQL सर्वर उठाया।

 docker run --rm --detach --name mssql-server \ --publish 1433:1433 \ --env ACCEPT_EULA=Y \ --env SA_PASSWORD=Password12! \ mcr.microsoft.com/mssql/server:2017-latest 

अब कल्पना करें कि हमारे पास एक कार्य है: हमें Stopwatch का उपयोग करके डेटाबेस के लिए सभी प्रश्नों के निष्पादन समय को मापने की आवश्यकता है और कंसोल में "अनुरोध" - "रनटाइम" जोड़े प्रदर्शित करें।

बेशक, आप बस उस कोड के QuerySingleAsync कॉल QuerySingleAsync लपेट सकते हैं जो Stopwatch आवृत्ति बनाता है और शुरू होता है, क्वेरी निष्पादित होने के बाद इसे रोक देता है और परिणाम प्रदर्शित करता है, लेकिन एक ही बार में कई कठिनाइयां हैं:

• क्या होगा यदि आवेदन में एक से अधिक अनुरोध हैं?
• क्या होगा यदि अनुरोध को निष्पादित करने वाला कोड पहले से ही संकलित है, एक NuGet पैकेज के रूप में एप्लिकेशन से जुड़ा है, और हमारे पास इसे बदलने का कोई तरीका नहीं है?
• क्या होगा यदि डेटाबेस पर क्वेरी डैपर के माध्यम से नहीं की जाती है, लेकिन EntityFramework के माध्यम से, उदाहरण के लिए, और हमारे पास DbCommand ऑब्जेक्ट या उत्पन्न क्वेरी टेक्स्ट तक पहुंच नहीं है जो वास्तव में निष्पादित होगी?

चलिए DiagnosticSource का उपयोग करके इस समस्या को हल करने का प्रयास करते हैं।

NuGet System.Diagnostics.DiagnosticSource पैकेज का उपयोग करना

System.Diagnostics.DiagnosticSource के NuGet पैकेज को जोड़ने के बाद करने वाली पहली चीज़ एक ऐसी क्लास बनाना है जो हमारे लिए रूचि की घटनाओं को हैंडल करेगी:

 public sealed class ExampleDiagnosticObserver { } 

प्रसंस्करण की घटनाओं को शुरू करने के लिए, आपको इस वर्ग का एक उदाहरण बनाने और स्थैतिक ऑब्जेक्ट DiagnosticListener.AllListeners लिस्टनर में सभी पर्यवेक्षक के रूप में पंजीकृत करने की आवश्यकता है। सभी ( System.Diagnostics नाम स्थान में स्थित)। हम इसे Main समारोह की शुरुआत में करते हैं:

 public static async Task Main() { var observer = new ExampleDiagnosticObserver(); IDisposable subscription = DiagnosticListener.AllListeners.Subscribe(observer); var answer = await GetAnswerAsync(); Console.WriteLine(answer); } 

इस मामले में, कंपाइलर हमें ठीक से बताएगा कि ExampleDiagnosticObserver वर्ग को IObserver<DiagnosticListener> इंटरफ़ेस लागू करना चाहिए। आइए इसे लागू करें:

 public sealed class ExampleDiagnosticObserver : IObserver<DiagnosticListener> { void IObserver<DiagnosticListener>.OnNext(DiagnosticListener diagnosticListener) { Console.WriteLine(diagnosticListener.Name); } void IObserver<DiagnosticListener>.OnError(Exception error) { } void IObserver<DiagnosticListener>.OnCompleted() { } } 

यदि हम अभी यह कोड चलाते हैं, तो हम देखेंगे कि निम्नलिखित कंसोल में प्रदर्शित होंगे:

 SqlClientDiagnosticListener SqlClientDiagnosticListener 42 

इसका मतलब यह है कि कहीं न कहीं। में DiagnosticListener प्रकार की दो वस्तुओं को "SqlClientDiagnosticListener" नाम से पंजीकृत किया गया है, जब इस कोड को निष्पादित किया गया था।

IObserver<DiagnosticListener>.OnNext का उपयोग करने के लिए एक बार पहले DiagnosticListener प्रत्येक उदाहरण के लिए उपयोग किया जाता है जिसे एप्लिकेशन में बनाया जाता है (आमतौर पर वे स्थिर गुणों के रूप में बनाए जाते हैं)। अब हमने कंसोल में DiagnosticListener इंस्टेंस का नाम प्रदर्शित किया है, लेकिन व्यवहार में इस विधि को इस नाम की जाँच करने की आवश्यकता है और, यदि हम इस उदाहरण से घटनाओं को संसाधित करने में रुचि रखते हैं, तो Subscribe विधि का उपयोग करके इसे Subscribe ।

मैं यह भी नोट करना चाहता हूं कि जब हम DiagnosticListener.AllListeners.Subscribe कॉल करते हैं DiagnosticListener.AllListeners.Subscribe तो हमें परिणामस्वरूप एक subscription ऑब्जेक्ट मिलेगा, जो IDisposable इंटरफ़ेस को लागू करता है। इस ऑब्जेक्ट पर IObserver<DiagnosticListener>.OnCompleted विधि को कॉल करने से सदस्यता समाप्त हो जाएगी, जिसे IObserver<DiagnosticListener>.OnCompleted में लागू किया जाना चाहिए।

IObserver<DiagnosticListener> लागू करें IObserver<DiagnosticListener> फिर से:

 public sealed class ExampleDiagnosticObserver : IObserver<DiagnosticListener> { private readonly List<IDisposable> _subscriptions = new List<IDisposable>(); void IObserver<DiagnosticListener>.OnNext(DiagnosticListener diagnosticListener) { if (diagnosticListener.Name == "SqlClientDiagnosticListener") { var subscription = diagnosticListener.Subscribe(this); _subscriptions.Add(subscription); } } void IObserver<DiagnosticListener>.OnError(Exception error) { } void IObserver<DiagnosticListener>.OnCompleted() { _subscriptions.ForEach(x => x.Dispose()); _subscriptions.Clear(); } } 

अब कंपाइलर हमें बताएगा कि हमारे ExampleDiagnosticObserver वर्ग को IObserver<KeyValuePair<string, object>> interface को भी लागू करना चाहिए। यहां हमें IObserver<KeyValuePair<string, object>>.OnNext को लागू करने की आवश्यकता है, जो एक पैरामीटर के रूप में KeyValuePair<string, object> स्वीकार करता है, जहां कुंजी ईवेंट का नाम है, और मान एक अनाम ऑब्जेक्ट (आमतौर पर) है जो मनमाने मापदंडों के साथ है जिसका हम उपयोग कर सकते हैं। अपने विवेक पर। आइए इस इंटरफ़ेस का कार्यान्वयन जोड़ें:

 public sealed class ExampleDiagnosticObserver : IObserver<DiagnosticListener>, IObserver<KeyValuePair<string, object>> { // IObserver<DiagnosticListener> implementation // ... void IObserver<KeyValuePair<string, object>>.OnNext(KeyValuePair<string, object> pair) { Write(pair.Key, pair.Value); } void IObserver<KeyValuePair<string, object>>.OnError(Exception error) { } void IObserver<KeyValuePair<string, object>>.OnCompleted() { } private void Write(string name, object value) { Console.WriteLine(name); Console.WriteLine(value); Console.WriteLine(); } } 

यदि हम अब परिणामी कोड चलाते हैं, तो निम्नलिखित कंसोल में प्रदर्शित होंगे:

 System.Data.SqlClient.WriteConnectionOpenBefore { OperationId = 3da1b5d4-9ce1-4f28-b1ff-6a5bfc9d64b8, Operation = OpenAsync, Connection = System.Data.SqlClient.SqlConnection, Timestamp = 26978341062 } System.Data.SqlClient.WriteConnectionOpenAfter { OperationId = 3da1b5d4-9ce1-4f28-b1ff-6a5bfc9d64b8, Operation = OpenAsync, ConnectionId = 84bd0095-9831-456b-8ebc-cb9dc2017368, Connection = System.Data.SqlClient.SqlConnection, Statistics = System.Data.SqlClient.SqlStatistics+StatisticsDictionary, Timestamp = 26978631500 } System.Data.SqlClient.WriteCommandBefore { OperationId = 5c6d300c-bc49-4f80-9211-693fa1e2497c, Operation = ExecuteReaderAsync, ConnectionId = 84bd0095-9831-456b-8ebc-cb9dc2017368, Command = System.Data.SqlClient.SqlComman d } System.Data.SqlClient.WriteCommandAfter { OperationId = 5c6d300c-bc49-4f80-9211-693fa1e2497c, Operation = ExecuteReaderAsync, ConnectionId = 84bd0095-9831-456b-8ebc-cb9dc2017368, Command = System.Data.SqlClient.SqlComman d, Statistics = System.Data.SqlClient.SqlStatistics+StatisticsDictionary, Timestamp = 26978709490 } System.Data.SqlClient.WriteConnectionCloseBefore { OperationId = 3f6bfd8f-e5f6-48b7-82c7-41aeab881142, Operation = Close, ConnectionId = 84bd0095-9831-456b-8ebc-cb9dc2017368, Connection = System.Data.SqlClient.SqlConnection, Stat istics = System.Data.SqlClient.SqlStatistics+StatisticsDictionary, Timestamp = 26978760625 } System.Data.SqlClient.WriteConnectionCloseAfter { OperationId = 3f6bfd8f-e5f6-48b7-82c7-41aeab881142, Operation = Close, ConnectionId = 84bd0095-9831-456b-8ebc-cb9dc2017368, Connection = System.Data.SqlClient.SqlConnection, Stat istics = System.Data.SqlClient.SqlStatistics+StatisticsDictionary, Timestamp = 26978772888 } 42 

कुल मिलाकर, हम छह घटनाओं को देखेंगे। उनमें से दो को डेटाबेस से कनेक्शन खोलने से पहले और बाद में निष्पादित किया जाता है, दो - कमांड निष्पादित होने से पहले और बाद में, और दो और - डेटाबेस से कनेक्शन को बंद करने से पहले और बाद में।

प्रत्येक घटना में पैरामीटर का एक सेट होता है, जैसे कि OperationId , ConnectionId , Connection , Command , जो आमतौर पर एक अनाम वस्तु के गुणों के रूप में पारित किए जाते हैं। आप इन गुणों के लिए टाइप किए गए मान प्राप्त कर सकते हैं, उदाहरण के लिए, प्रतिबिंब का उपयोग करके। (व्यवहार में, प्रतिबिंब का उपयोग करना बहुत वांछनीय नहीं हो सकता है। हम घटना के मापदंडों को प्राप्त करने के लिए डायनेमिकमेथोड का उपयोग करते हैं।)

अब हम प्रारंभिक समस्या को हल करने के लिए तैयार हैं - डेटाबेस के सभी अनुरोधों के निष्पादन समय को मापने के लिए और इसे मूल अनुरोध के साथ कंसोल में प्रदर्शित करें।

निम्नानुसार Write विधि के कार्यान्वयन को बदलें:

 public sealed class ExampleDiagnosticObserver : IObserver<DiagnosticListener>, IObserver<KeyValuePair<string, object>> { // IObserver<DiagnosticListener> implementation // ... // IObserver<KeyValuePair<string, object>> implementation // ... private readonly AsyncLocal<Stopwatch> _stopwatch = new AsyncLocal<Stopwatch>(); private void Write(string name, object value) { switch (name) { case "System.Data.SqlClient.WriteCommandBefore": { //           _stopwatch.Value = Stopwatch.StartNew(); break; } case "System.Data.SqlClient.WriteCommandAfter": { //           var stopwatch = _stopwatch.Value; stopwatch.Stop(); var command = GetProperty<SqlCommand>(value, "Command"); Console.WriteLine($"CommandText: {command.CommandText}"); Console.WriteLine($"Elapsed: {stopwatch.Elapsed}"); Console.WriteLine(); break; } } } private static T GetProperty<T>(object value, string name) { return (T) value.GetType() .GetProperty(name) .GetValue(value); } } 

यहां हम डेटाबेस के लिए अनुरोध की शुरुआत और अंत की घटनाओं को रोकते हैं। अनुरोध को निष्पादित करने से पहले, हम स्टॉपवॉच बनाते हैं और शुरू करते हैं, इसे बाद में वापस लाने के लिए, AsyncLocal<Stopwatch> एक चर में इसे सहेजते हैं। अनुरोध को निष्पादित करने के बाद, हम पहले लॉन्च किए गए स्टॉपवॉच प्राप्त करते हैं, इसे रोकते हैं, प्रतिबिंब के माध्यम से value पैरामीटर से निष्पादित कमांड प्राप्त करते हैं और परिणाम को कंसोल पर प्रिंट करते हैं।

यदि हम अब परिणामी कोड चलाते हैं, तो निम्नलिखित कंसोल में प्रदर्शित होंगे:

 CommandText: SELECT 42; Elapsed: 00:00:00.0341357 42 

ऐसा लगता है कि हम पहले से ही अपनी समस्या का समाधान कर चुके हैं, लेकिन एक छोटा सा विवरण शेष है। तथ्य यह है कि जब हम DiagnosticListener ईवेंट की सदस्यता लेते हैं, तो हम इसे उन घटनाओं से भी प्राप्त करना शुरू करते हैं जो हमारे लिए दिलचस्प नहीं हैं, और चूंकि प्रत्येक ईवेंट को पैरामीटर के साथ एक अनाम ऑब्जेक्ट बनाया जाता है, इसलिए यह GC पर एक अतिरिक्त लोड बना सकता है।

इस स्थिति से बचने के लिए और आपको यह बताने के लिए कि हम कौन सी घटनाओं का DiagnosticListener करने जा रहे हैं, हम सब्सक्राइब करते समय Predicate<string> टाइप के एक विशेष प्रतिनिधि को निर्दिष्ट कर सकते हैं, जो इवेंट का नाम एक पैरामीटर के रूप में लेता है और true यदि इस ईवेंट को संसाधित किया जाना चाहिए।

IObserver<DiagnosticListener>.OnNext अपनी कक्षा में IObserver<DiagnosticListener>.OnNext को IObserver<DiagnosticListener>.OnNext :

 void IObserver<DiagnosticListener>.OnNext(DiagnosticListener diagnosticListener) { if (diagnosticListener.Name == "SqlClientDiagnosticListener") { var subscription = diagnosticListener.Subscribe(this, IsEnabled); _subscriptions.Add(subscription); } } private bool IsEnabled(string name) { return name == "System.Data.SqlClient.WriteCommandBefore" || name == "System.Data.SqlClient.WriteCommandAfter"; } 

अब हमारा Write तरीका केवल "System.Data.SqlClient.WriteCommandBefore" और "System.Data.SqlClient.WriteCommandAfter" घटनाओं के लिए बुलाया जाएगा।

Microsoft के NuGet Package.Extensions.DiagnosticAdapter का उपयोग करना

चूंकि घटना के पैरामीटर जो हम DiagnosticListener से प्राप्त करते हैं, उन्हें आमतौर पर एक अनाम वस्तु के रूप में पारित किया जाता है, प्रतिबिंब के माध्यम से उन्हें पुनर्प्राप्त करना बहुत महंगा हो सकता है। सौभाग्य से, Microsoft.Extensions.DiagnosticAdapter NuGet पैकेज है जो हमारे लिए ऐसा कर सकता है, System.Reflection.Emit से रनटाइम कोड पीढ़ी का उपयोग कर रहा है।

इस पद्धति का उपयोग करने के लिए, जब Subscribe विधि के बजाय DiagnosticListener उदाहरण से घटनाओं की Subscribe लेते हैं, तो आपको SubscribeWithAdapter एक्सटेंशन विधि का उपयोग करना होगा। इस मामले में IObserver<KeyValuePair<string, object>> interface को लागू करना अब आवश्यक नहीं है। इसके बजाय, प्रत्येक घटना के लिए जिसे हम संभालना चाहते हैं, हमें एक अलग विधि की घोषणा करने की आवश्यकता है, इसे DiagnosticNameAttribute विशेषता ( Microsoft.Extensions.DiagnosticAdapter नामस्थान से) के साथ चिह्नित करना है। इन विधियों के पैरामीटर संसाधित किए जा रहे इवेंट के पैरामीटर होंगे।

अगर हम इस NuGet पैकेज का उपयोग करके अपने ExampleDiagnosticObserver वर्ग को फिर से लिखते हैं, तो हमें निम्नलिखित कोड मिलते हैं:

 public sealed class ExampleDiagnosticObserver : IObserver<DiagnosticListener> { private readonly List<IDisposable> _subscriptions = new List<IDisposable>(); void IObserver<DiagnosticListener>.OnNext(DiagnosticListener diagnosticListener) { if (diagnosticListener.Name == "SqlClientDiagnosticListener") { var subscription = diagnosticListener.SubscribeWithAdapter(this); _subscriptions.Add(subscription); } } void IObserver<DiagnosticListener>.OnError(Exception error) { } void IObserver<DiagnosticListener>.OnCompleted() { _subscriptions.ForEach(x => x.Dispose()); _subscriptions.Clear(); } private readonly AsyncLocal<Stopwatch> _stopwatch = new AsyncLocal<Stopwatch>(); [DiagnosticName("System.Data.SqlClient.WriteCommandBefore")] public void OnCommandBefore() { _stopwatch.Value = Stopwatch.StartNew(); } [DiagnosticName("System.Data.SqlClient.WriteCommandAfter")] public void OnCommandAfter(DbCommand command) { var stopwatch = _stopwatch.Value; stopwatch.Stop(); Console.WriteLine($"CommandText: {command.CommandText}"); Console.WriteLine($"Elapsed: {stopwatch.Elapsed}"); Console.WriteLine(); } } 

इस प्रकार, अब हम अपने एप्लिकेशन से डेटाबेस में सभी प्रश्नों के निष्पादन समय को माप सकते हैं, व्यावहारिक रूप से एप्लिकेशन के कोड को बदले बिना।

अपनी खुद की DiagnosticListener उदाहरण बनाना

व्यवहार में DiagnosticSource का उपयोग करते समय, ज्यादातर मामलों में आप मौजूदा घटनाओं की सदस्यता लेंगे। आपको सबसे अधिक संभावना है कि आपको अपने खुद के DiagnosticListener और अपनी खुद की घटनाओं को भेजना होगा (केवल अगर आप किसी भी पुस्तकालय का विकास नहीं कर रहे हैं), तो मैं इस खंड पर लंबे समय तक नहीं रहूंगा।

DiagnosticListener का अपना उदाहरण बनाने के लिए आपको इसे कोड में कहीं एक स्थिर चर के रूप में घोषित करना होगा:

 private static readonly DiagnosticSource _myDiagnosticSource = new DiagnosticListener("MyLibraty"); 

उसके बाद, किसी ईवेंट को भेजने के लिए, आप फ़ॉर्म के डिज़ाइन का उपयोग कर सकते हैं:

 if (_myDiagnosticSource.IsEnabled("MyEvent")) _myDiagnosticSource.Write("MyEvent", new { /* parameters */ }); 

अपना खुद का DiagnosticListener इंस्टेंस बनाने के बारे में अधिक जानकारी के लिए DiagnosticSource उपयोगकर्ता मार्गदर्शिका देखें , जिसमें DiagnosticSource का उपयोग करने के लिए सर्वोत्तम अभ्यासों का विवरण दिया गया है।

निष्कर्ष

हमने जो उदाहरण दिया, वह निश्चित रूप से बहुत सारगर्भित है और वास्तविक परियोजना में उपयोगी होने की संभावना नहीं है। लेकिन यह पूरी तरह से दिखाता है कि इस तंत्र का उपयोग आपके अनुप्रयोगों की निगरानी और निदान के लिए कैसे किया जा सकता है।

अगले लेख में, मैं मेरे लिए ज्ञात घटनाओं की एक सूची दूंगा जो कि DiagnosticSource के माध्यम से संसाधित की जा सकती हैं, और इसके उपयोग के कुछ व्यावहारिक उदाहरण दिखा सकते हैं।