ארכיון

ארכיון לקטגוריה ‘תכנות’

SMS Integration: Israel is wayyy behind US

14 מרץ, 2010 רון קליין אין תגובות

והפעם פוסט סביב אינטגרציה.

החלטנו להוסיף למוצר שלנו מערכת התראות ב SMS. הנמענים אמורים להיות בישראל, בלי מגבלה על הרשתות והמפעילים.
האינסטינקט הראשוני הוא ליצור קשר עם ספקי SMS בישראל, שמאפשרים התממשקות באמצעות Web Service כזה או אחר, להתרשם ולקנות חבילה.
גיגלתי ומצאתי שני ספקים ישראליים:

  • SimpleSMS
  • שירות של גולדמן תקשורת שנקרא SMS API

התרשמתי מ SimpleSMS לטובה. האתר שלהם נראה נחמד, יש תיעוד טוב ודוגמאות קוד לשפות תכנות רבות, גם לדוט נט. ואז רציתי לשלם. אחרי מילוי מושקע של הפרטים, קבלתי הודעת שגיאה לא ברורה עם מסך של טרנזילה. ועכשיו אני בבעיה: היה חיוב או לא היה חיוב?
בצר לי, התקשרתי. מכירים את המוקדים הטלפוניים האלה, שעונים לכם אנשים חינניים שבכלל לא קשורים לעסק עצמו, אלא רק שם כדי לקבל שיחות ולהעביר את הקריאה הלאה? כן כן, זה מה שהיה שם, ואמרו שיתקשרו אלי תוך 45 דקות. אחרי חצי שעה ניסיתי שוב, והדגשתי שזו הודעה שניה. כל זה היה לפני שבוע בערך, ואני עדיין מחכה.
אז אם אין שירות סביר ל SimpleSMS, אין טעם שאני אשאר איתם. מזל שיש מתחרים.

אז כאמור, גולדמן תקשורת. שם זה סיפור אחר: באתר שלהם מדברים על API בצורת Web Service, ואפילו יש screenshot שממחיש את זה, אבל תיעוד אמיתי אין. ודוגמאות קוד, זה בכלל "מוקצה". האמת, חייבים להיכנס ולראות כדי להאמין.
אבל אני, אופטימיסט אני. אמרתי, ניתן צ'אנס, נרים טלפון. התקשרתי ובקשתי לנסות את המוצר, או לפחות לקבל את ה API הנכסף (ולא ב screenshot). מהעבר השני של הקו הסביר לי, בתקיפות לא ברורה, שהם היחידים שעובדים דרך סלקום, כבר שנים, ושהמתחרים לא אמינים כמותם. הסיטואציה לא היתה מספיק ברורה (לשנינו, כנראה), וסיכמנו שכדאי לי לדבר עם אסף, הבן שלו, בעניין ה API.
מסתבר שתחום ה pre sales בגולדמן תקשורת קצת בעייתי, כי אסף סרב לספק את התיעוד ל API, והסביר שאני צריך לקנות את השירות כדי לקבל את ה API והתיעוד. עכשיו, נכון שהחבילה המינימלית עולה בסה"כ 20 ש"ח, וזה סכום פעוט לחברות תוכנה, אבל למה להחביא את ה API? מה כל כך סודי בו? אסף הסביר לי שמנסיון העבר שיש להם, זו מדיניות החברה.
יש משהו קצת פישי בהסתרת API, ולא בעיה להרים שירות Dummy שיהווה "מתקן אימונים" אם רוצים להסתיר את הכתובת של השירות האמיתי. במילים אחרות, אני לא רואה בעיה שהיא לא פתירה, ובגלל זה אני מסיק שיש כאן בעיה של מקצועיות.
אז גם גולדמן תקשורת נפסל.

באותו זמן, ומהעבר השני של החדר, כלומר במרחק של מטר וחצי ממני, רשף כבר נרשם לשירות אמריקאי שנקרא Twilio. הם שולחים הודעות SMS להרבה מקומות בעולם, גם לישראל. תוך חצי שעה כבר נרשמנו, שילמנו (עם סליקה מוצלחת!), והיה לנו קוד מלא ועובד.

נחזור רגע לאינסטינקט הראשוני (מתחילת הפוסט), שאומר שבשביל שירות אינטגרציה מקומי כדאי לפנות לספקים מקומיים, כי הם בטח מתמצאים יותר ויהיו דרכם פחות בעיות טכניות. מסתבר שהפעם, פניה לספק חיצוני העלתה תוצאה טובה יותר: האמריקאים כנראה יודעים לעשות את זה טוב יותר ומקצועי יותר מהישראלים (ובכמות גדולה של הודעות, גם זול יותר). אולי כי הסליקה שלהם עובדת בלי בעיה, ואולי כי הכל פשוט מתקתק כמו שצריך, עם שירות מבוסס ReST, ועם תיעוד מלא ומקיף (ולא מוסתר…).
זה אולי לא מדגם מייצג, אבל בכל זאת, בשנת 2010, הייתי מצפה מחברות טכנולוגיה/אינטגרציה מקומיות להרים שירות בסטנדרט גבוה יותר.

לא נורא, העיקר שעובד :-)

קטגוריות:אינטגרציה, תכנות תגיות:,

Startable – State Machine part 1

11 מרץ, 2010 רון קליין אין תגובות

בפוסט הזה:

  • קצת על State Machine
  • Startable State Machine
  • מתי משתמשים
  • מימוש רגיל
  • הפרדת interface מהמימוש
  • מימוש עם נעילות
  • הדגמה פשוטה

בפוסט הבא אני אראה איך אפשר להשתמש ב state machine הזה (בירושה, למשל)

קצת על State Machine

חלק משמעותי מעולם התכנות כולל מעבר ממצב x למצב y, כאשר כל המצבים ידועים מראש. אפשר לומר שכל התוכניות שכתבתי עד היום הן כאלו. אמנם,לא תמיד ידעתי לצפות מראש את כל המצבים, ופה ושם היו באגים שבדרכם גרמו לי להבין שיש עוד מצב או שניים שצריך לקחת בחשבון, אבל בסופו של דבר, זו היתה קבוצה סגורה ומוגדרת היטב של מצבים.

קבוצת המצבים הזו יכולה להיות מתוארת כמכונת מצבים (סופית), או באנגלית Finite State Machine, ובקיצור FSM. המעבר ממצב למצב נקרא transition ובד"כ הצורך לעבור ממצב אחד לאחר נובע מקלט כזה או אחר, או הודעה פנימית. אפשר לקרוא עוד בויקיפדיה (עברית ואנגלית) כדי להעמיק.

Startable State Machine

תרשו לי להציג מכונת מצבים פשוטה ונחמדה. אולי פשוטה מדי, אבל אני מקווה שאצליח לשכנע שהיא נחוצה ומעודדת שימוש חוזר בקוד (שזו מטרה נאה לכל הדעות). אני קורא למצבים פשוטים כאלה "mini patterns". לא ממש design pattern, אבל בהחלט מעודד שימוש חוזר בקוד.

מדובר בסה"כ בשני מצבים אפשריים: Started ו Stopped. או בעברית: מופעל/מופסק.

נדמיין שני לחצנים: לחצן Start ולחצן Stop (כמו Play ו Stop במכשיר DVD, למשל)

אם המצב הנוכחי הוא Stopped, ולחצנו על Start – עוברים למצב Started. כל לחיצה נוספת על Start לא משנה את המצב.

וכנ"ל להיפך: אם המצב הנוכחי הוא Started, ולחצנו על Stop – עוברים למצב Stopped. כל לחיצה נוספת על Stop לא משנה את המצב.

לצורך העניין, מצב הפתיחה הוא Stopped.

התרשים הבא יכול לתאר את זה:

Startable State Machine - chart

מתי משתמשים?

השימוש העיקרי שלי ב Startable הוא כשבתוך אפליקציה קיימת, אני צריך איזשהו שירות שיהיה פעיל ברקע כל הזמן, או פעיל לפעמים. למשל: שרת UDP שמאזין להודעות נכנסות בפורט מסויים, סטרימר ששולח Streaming Video למחשב אחר, רכיב שבודק כל X שניות מה הסטטוס של רכיב אחר, וכו' וכו'. לכל רכיב שכזה יש בד"כ שני מצבים: "פעיל" או "לא פעיל". קלאסי ל Startable.

מימוש רגיל

המימוש הוא די פשוט:

namespace Groundhog.Lib
{
    public enum StartableStatus
    {
        Started,
        Stopped
    }

    public class StartableStateMachine
    {
        private StartableStatus status;

        public event Action OnStart;
        public event Action OnStop;

        public StartableStateMachine() : this(StartableStatus.Stopped)
        {
        }

        public StartableStateMachine(StartableStatus initialStatus)
        {
            status = initialStatus;
        }

        private void InvokeAction(Action e)
        {
            if (null == e)
                return;
            e();
        }

        private void InvokeOnStop()
        {
            InvokeAction(OnStop);
        }

        private void InvokeOnStart()
        {
            InvokeAction(OnStart);
        }

        public void Start()
        {
            if (status == StartableStatus.Started)
                return;

            // it was "stopped"
            // change to "started"            
            status = StartableStatus.Started;
            // and raise the proper event
            InvokeOnStart();
        }

        public void Stop()
        {
            if (status == StartableStatus.Stopped)
                return;

            // it was "started"
            // change to "stopped"            
            status = StartableStatus.Stopped;
            // and raise the proper event
            InvokeOnStop();
        }

        public StartableStatus Status
        {
            get
            {
                return status;
            }
        }        
    }
}

סקירת קוד קצרה:

  • יש כאן enum על הסטטוס: Started או Stopped
  • אפשר לקבל את הסטטוס הנוכחי באמצעות המאפיין Status (דה!)
  • בנוסף יש שתי מתודות: Start ו Stop שהן ה"לב" של ה state machine שלנו
  • וכדי להודיע לעולם שהסטטוס השתנה, יש שני אירועים: OnStart ו OnStop.

מה אין כאן?
הקוד הוא לא thread-safe, מיד נגיע לזה.

הפרדת interface מהמימוש

ממוש, תפריד לי את ה interface מהמימוש, טוב?
הנה, מותק:

namespace Groundhog.Lib
{
  public interface IStartableStateMachine
  {
    event Action OnStart;
    event Action OnStop;
    void Start();
    StartableStatus Status { get; }
    void Stop();
  }
}

ועכשיו, אחרי שיש לנו הפרדה בין החוזה למימוש, אפשר לממש בצורות אחרות.

מימוש עם נעילות

כדי שהקוד יהיה thread-safe, אפשר:

  • להשתמש בנעילות רגילות (או באבסטרקציה שהצעתי בפוסט אחר)
  • לעבוד עם Interlock, שמהווה מנגנון יותר light-weight לנעילות מהסוג שצריך כאן

כל הקוד לנעילות השונות נמצא בקובץ המצורף. אני לא נכנס לזה פשוט כי זה לא העיקר בפוסט הזה.

הדגמה פשוטה

הנה קוד של Console Application שנותן לנו קצת להרגיש את כל מה שהיה לנו עד עכשיו.

using Groundhog.Lib;
namespace Groundhog.ConsoleApp
{
  class Program
  {
    static void Main(string[] args)
    {
      IStartableStateMachine ssm = new StartableStateMachine();
      ssm.OnStart += MyOnStart;
      ssm.OnStop += MyOnStop;

      Console.WriteLine("===========================");
      Console.WriteLine("simple flow: start and stop");
      Console.WriteLine("===========================");
      Console.WriteLine(ssm.Status);
      ssm.Start();
      Console.WriteLine(ssm.Status);
      ssm.Stop();
      Console.WriteLine(ssm.Status);

      Console.WriteLine();
      Console.WriteLine();
      Console.WriteLine("========================================");
      Console.WriteLine("multiple starts and then multiple stops,");
      Console.WriteLine("should invoke each event just once");
      Console.WriteLine("========================================");
      ssm.Start();
      ssm.Start();
      ssm.Start();
      ssm.Start();
      Console.WriteLine(ssm.Status);
      ssm.Stop();
      ssm.Stop();
      ssm.Stop();
      ssm.Stop();
      ssm.Stop();
      Console.WriteLine(ssm.Status);

      Console.WriteLine();
      Console.WriteLine();
      Console.WriteLine("===================");
      Console.WriteLine("press enter to quit");
      Console.WriteLine("===================");
      Console.ReadLine();
    }

    static void MyOnStart()
    {
      Console.WriteLine("hey, it started!");
    }

    static void MyOnStop()
    {
      Console.WriteLine("dude, this thing stopped");
    }
  }
}

והפלט יהיה:

===========================
simple flow: start and stop
===========================
Stopped
hey, it started!
Started
dude, this thing stopped
Stopped

========================================
multiple starts and then multiple stops,
should invoke each event just once
========================================
hey, it started!
Started
dude, this thing stopped
Stopped

===================
press enter to quit
===================

כפי שניתן לראות, גם אחרי מספר קריאות עוקבות ל start, הסטטוס נשאר started, וכנ"ל גם לגבי קריאות למתודה stop. כלומר יש לנו state machine בדיוק כמו שרצינו.

בהזדמנות הבאה אני אראה איך משתמשים בקוד הזה בירושה (ובדרך נוספת), בדיוק עבור אותם רכיבים שמבצעים איזושהי עבודה ברקע.

תכנות נעים!

כל הקוד בפוסט הזה נמצא כאן.

קטגוריות:תכנות תגיות:,

Chainsaw Session at ALT.NET tools meeting

12 פברואר, 2010 רון קליין אין תגובות

לפני שבועיים בערך הייתי במפגש של קבוצת ALT.NET ישראל.
מה זה ALT.NET? הנה העקרון הכללי:

We are a self-organizing, ad-hoc community of developers bound by a desire to improve ourselves, challenge assumptions, and help each other pursue excellence in the practice of software development.

(מתוך אתר ALT.NET)
בקיצור, כן מתכנתים בדוט נט, אבל לא עם הראש בקיר (ובעיקר לא "כי ככה אמרו במיקרוסופט"). כן להיפגש, אבל לא בהרצאות מובנות, אלא בשיחה פתוחה.

המפגש שבו השתתפתי עסק יותר בכלים שונים שיכולים ללוות את המתכנת או לשנות את צורת העבודה שלו. אוהד ישראלי מתאר את זה בפוסט משלו. תודה לחן אגוזי על הארגון ולחברת Delver על האירוח :-)

אני נתתי session על Chainsaw, מתוך כוונה ברורה "להפיץ את הבשורה" ולאפשר למתכנתים נוספים להכיר את ה viewer החביב הזה. בהפסקה נגשו אלי פה ושם אנשים שאמרו שזה באמת מחדש להם והם ינסו את זה. אשריני. אפשר לצפות בוידאו, אבל בעיקר שומעים אותי, וגם זה בקושי. אז הנה, למיטיבי השמיעה שביניכם:

בהזדמנות אני אוסיף לפוסט את המצגת ואת קבצי המקור.

ניסור נעים!

קטגוריות:תכנות תגיות:,

We're Hiring

13 ינואר, 2010 רון קליין אין תגובות

החברה שבה אני עובד, אקסייטס מדיה, מגייסת בימים אלה עובדים/ות למשרות פיתוח.

בגדול מדובר בשלוש משרות פיתוח:

  1. Server Side Developer
  2. Web Developer
  3. Junior Developer

לתיאור המשרות ולפרטים נוספים – לחצו כאן.

קטגוריות:תכנות תגיות:

Locking by Decorator

9 ינואר, 2010 רון קליין אין תגובות

בפוסט הזה:

  • הקדמה
  • הגדרת החוזה
  • מימוש רגיל ללא נעילות
  • נעילה באמצעות Decorator
  • יישום

הקדמה

לא מזמן כתבתי פוסט שמציע להפריד בין לוגיקה של רכיב ללוגיקה של נעילה ע"י אבסטרקציה. בפוסט הזה אני מציע דרך נוספת לעטוף רכיב בנעילה, תוך שימוש ב Design Pattern שנקרא Decorator. המטרה היא שוב להפריד בין לוגיקת רכיב ללוגיקת נעילה, כדי ליצור קוד נקי יותר וגמיש יותר לפי צרכי הפרויקט.

הגדרת החוזה

כדי לא להסתבך יותר מדי, אני אמשיך את הרעיון מהפוסט ההוא, ולכן דוגמת ה Counter תלווה אותנו גם כאן. נמיר את ה Counter שלנו מ class ל interface באופן הבא:

public interface ICounter
{
    void Hit();
    int Current { get; }
}

מימוש רגיל ללא נעילות

המימוש הרגיל והמיידי ל interface הנ"ל:

public class Counter : ICounter
{
    private int counter = 0;

    public void Hit()
    {
        ++counter;
    }

    public int Current
    {
        get { return counter; }
    }        
}

עד כאן טוב ויפה, אבל המימוש הוא כמובן לא thread-safe. עם זאת, הלוגיקה שבמימוש הזה ברורה וקריאה, ונוכל לכתוב unit tests שמתייחסים למימוש הזה בצורה פשוטה ומהירה. זה יתרון חשוב.

נעילה באמצעות Decorator

קצת הקדמה: מה זה Decorator?

אז ככה: בגדול, Decorator זה Design Pattern שמתייחס ל interface-ים ולהוספת פונקציונליות בזמן ריצה, לא על ידי ירושה. אפשר לקרוא עוד בויקיפדיה. במקרה שלפנינו, נוסיף פונקציונליות של נעילה על המימוש של ICounter. או, בניסוח אחר: "נקשט" את הפונקציונליות של Counter בנעילה, אבל נשמור על ה interface. כלומר החוזה נשמר אבל נקבל עוד משהו במימושים.

ניגש לקוד עצמו של ה Decorator שלנו:

public class CounterLockDecorator : ICounter
{
    private readonly ICounter core;
    private readonly object syncObject = new object();

    public CounterLockDecorator(ICounter coreCounter)
    {
        if (null == coreCounter)
            throw new ArgumentNullException("coreCounter");

        core = coreCounter;
    }

    public void Hit()
    {
        lock (syncObject)
        {
            core.Hit();
        }
    }

    public int Current
    {
        get
        {
            lock (syncObject)
            {
                return core.Current;
            }
        }
    }
}

כפי שניתן לראות, ה Decorator מממש בעצמו את החוזה ICounter. אבל הוא לא עושה את כל העבודה – הוא מצפה לקבל בקונסטרקטור שלו מימוש קיים ל ICounter ו"מגלגל" אליו את הקריאות לפי הצורך. כך, למשל, במימוש של המתודה Hit: ה Decorator רק עוטף בנעילה את הקריאה למתודת ה Hit של המימוש הקיים שהוא מחזיק.

יישום

הקריאה ל Counter הרגיל, ללא נעילות, יכולה להתבצע כך:

ICounter myCounter = new Counter();

ואם רוצים את הפונקציונליות של הנעילות, נוכל לקבל ICounter באופן הבא:

ICounter myCounter = new CounterLockDecorator(new Counter());

סיכום

גם בפוסט הזה הראיתי כיצד ניתן להפריד בין הלוגיקה של הרכיב לבין הנעילות שלו. יש להפרדה הזו גם יתרונות וגם חסרונות. היתרונות העיקריים הם קוד גמיש וטסטבילי (כלומר כזה שניתן לבדיקות בצורה קלה). גם הקוד של הרכיב עצמו קריא וברור. עם זאת, יש אי אילו חסרונות להפרדה הזו: פתאום יש שלושה קבצים לתחזק (החוזה, המימוש הרגיל וה decorator) במקום אחד, והקריאה הופכת להיות קצת יותר מורכבת (אפשר לפתור את זה עם factory). יש פתרון נוסף לעניין הזה, והוא שימוש ב dynamic proxy. אם יהיה לי זמן אני ארחיב על זה, אבל הרעיון הכללי הוא ליצור את ה Decorator בזמן ריצה באמצעות הכלים הסטנדרטיים של דוט נט כמו CodeDOM או באמצעות פריימוורק שהוא קצת יותר high level כמו Dynamic Proxy של Castle.

אגב, אפשר להשתמש בנעילה האבסטרקטית שהצעתי בפוסט ההוא בתוך ה Decorator וכך "להרוויח" עוד קצת גמישות בבחירת מנגנון הנעילה עצמו, אבל זה כבר עניין אחר :-)

כל הקוד נמצא כאן, ושיהיה קישוט נעים!

קטגוריות:תכנות תגיות:, , ,

Tip: Setting a startup project in the .sln file

8 ינואר, 2010 רון קליין אין תגובות

הכנתי פרויקט Lib מסוג Class Library והכנתי פרויקט Demo (שמשתמש ב Lib) מסוג Console Application, ושניהם באותו solution.
שמרתי הכל, והגדרתי שה Demo יהיה ה startup project. הגיוני.
ועכשיו רציתי לשים את הכל כדוגמה לפוסט, אז כיווצתי הכל ל zip.

רק שניה, לפני שאני מעלה את זה, רק כדי לוודא שהכל עובד, אני פותח את הזיפ בתיקיה חדשה וריקה, ומשם פותח את ה Visual Studio 2008 ולוחץ F5 כדי להריץ… ופתאום הוא בוכה שאי אפשר להריץ Class Library, ואני הרי זוכר שממש לפני דקה הגדרתי שה startup project יהיה ה Demo. :mad:

טוב, בטח אני לא הראשון שנתקל בזה, אז קדימה לגגל!
הגעתי (איך לא) לדיון דומה ב stackoverflow.com, וגם לפוסט בנושא בבלוג של Arian Kulp.
מה מסתבר? שההגדרה של ה startup project לא נשמרת ב sln, אלא ב suo. :shock:
יש דרך לעקוף את זה:
פותחים את קובץ ה sln באיזה text editor כמו notepad (אני אישית מעריץ נלהב של NPP), ושם יש שורות כמו אלו:

Microsoft Visual Studio Solution File, Format Version 10.00
# Visual Studio 2008
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Lib", "Lib\Lib.csproj", "{F959D3D9-052F-4C62-B957-BF6459CB2209}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Demo", "Demo\Demo.csproj", "{852E3624-B5EB-40DF-A2EE-481037C8F47B}"
EndProject
…

פשוט מעבירים את החלק של Project…EndProject של הפרוייקט הרצוי להיות הראשון. בהמשך לדוגמה הזו, המצב הרצוי הוא:

Microsoft Visual Studio Solution File, Format Version 10.00
# Visual Studio 2008
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Demo", "Demo\Demo.csproj", "{852E3624-B5EB-40DF-A2EE-481037C8F47B}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Lib", "Lib\Lib.csproj", "{F959D3D9-052F-4C62-B957-BF6459CB2209}"
EndProject
…

וזה עושה את העבודה.

שימושי כשרוצים להוסיף פרויקט דוגמה לפוסט, ו/או בפרויקטים של קוד פתוח ברשת.
תוכלו לנסות בעצמכם :-)

קטגוריות:תכנות תגיות:,

From lock to abstract locker

6 ינואר, 2010 רון קליין 2 תגובות

כמו שמשתמע מהכותרת של הפוסט הזה, לא חייבים לנעול דווקא עם lock (כלומר נעילה שמבוססת על Monitor).
יש נעילות נוספות (למשל, Spin-Lock), ולכן אני מציע כאן אבסטרקציה לנעילה.

במילים אחרות, במקום הקוד הזה:

lock(locker)
{
    // do something
}

אני מציע משהו כזה:

locker.Enter();
// do something
locker.Exit();

אלא שזה קצת מעצבן, ולכן אפשר לשכלל את זה אם נשתמש ב IDisposable וניצור משהו יותר נחמד עם ה using שהוא סוג של מאקרו בדוט נט:

using(locker.EnterLock())
{
    // do something
}

אז בפוסט הזה יש:

  • קצת אבסטרקציה
  • קצת מוטיבציה
  • קוד בסיס
  • 2 ירושות
  • וקצת אינטגרציה :-)

קצת מוטיבציה

מתי זה שימושי?
-בעיקר אם נרצה לכתוב class שיכול להיות שימושי גם בסביבה שהיא single-threaded וגם בסביבה שהיא multi-threaded.

קצת קוד בסיס

ניגש לקוד עצמו. הנה ה base class עם תוספת פנימית בשביל ה using הנכסף:

using System;

public abstract class LockerBase
{
    public abstract void Enter();
    public abstract void Exit();

    public class DisposableLocker : IDisposable
    {
        private readonly LockerBase locker;

        public DisposableLocker(LockerBase locker)
        {
            this.locker = locker;
        }

        public void Dispose()
        {
            locker.Exit();
        }
    }

    public DisposableLocker EnterLock()
    {
        Enter();
        return new DisposableLocker(this);
    }
}

המתודות Enter ו Exit הן אבסטרקטיות, וכל מי שירצה לרשת מה base class הזה יצטרך לממש אותן.
אגב, אני לא מת על ירושה (לא בתכנות, לפחות), אבל כאן זה נראה יותר מתאים, כי יש איזה state לשמור עליו.

ירושה – המימוש ה"רגיל"

בואו נראה למשל, את המימוש המתבקש לנעילה "שגרתית":

using System.Threading;

public class MonitorLocker : LockerBase
{
    private readonly object syncRoot;

    public MonitorLocker(object syncObject)
    {
        syncRoot = syncObject;
    }

    public MonitorLocker() : this(new object())
    {
    }

    public override void Enter()
    {
        Monitor.Enter(syncRoot);
    }

    public override void Exit()
    {
        Monitor.Exit(syncRoot);
    }        
}

בקונסטרקטור נשים אובייקט שתפקידו להיות המשאב המשותף שעליו מבוססים השיתוף והנעילה.

ירושה – המימוש הריק

ועכשיו לקוד קצת אחר: class שלמעשה לא נועל. מעין dummy class שרק שומר על הפונקציונליות כלפי חוץ:

public class DummyLocker : LockerBase
{
    public override void Enter()
    {
    }

    public override void Exit()
    {
    }
}

בעקרון ה class הזה לא ישבור קומפילציה, אבל הוא לא באמת נועל כלום. זה ה dummy שלנו למקרה שמריצים את הקוד בסביבה שהיא single-threaded.

קצת אינטגרציה

אחרי כל הקוד הזה, נראה שימוש לאבסטרקציה הזו. נניח שיש לנו class בשם Counter. כל מה שיש שם זה מתודה בשם Hit ופרופרטי בשם Current.
וכל מה שצריך לקרות זה שכל קריאה ל Hit מעלה ב 1 את הערך של Current (שערכו ההתחלתי הוא 0).
אנחנו יודעים מראש שיהיו מצבים שבהם ה class הזה יהיה שימושי בסביבה שהיא single-threaded וכן בסביבה שהיא multi-threaded. לכן נשתמש בנעילה האבסטרקטית:

public class Counter
{
    private readonly LockerBase locker;
    private int counter = 0;

    public Counter(LockerBase locker)
    {
        this.locker = locker;
    }

    public void Hit()
    {
        using (locker.EnterLock())
        {
            ++counter;
        }

    }

    public int Current
    {
        get
        {
            using (locker.EnterLock())
            {
                return counter;
            }
        }
    }
}

הקוד די פשוט: כל התייחסות ל counter הפנימי "עטופה" בנעילה, אבל אנחנו לא יודעים מה יהיה המנעול שאיתו נעבוד.
המנעול עצמו יכנס ל class דרך הקונסטרקטור (ולזה קוראים Dependency Injection).
כך, למשל, ניצור instance של Counter לסביבה שהיא single-threaded (כלומר ללא צורך בנעילות):

Counter myCounter = new Counter(new DummyLocker());

אבל, כדי לא לעצבן את המתכנת שישתמש ב class הזה, אולי כדאי שנוסיף overload עם ה dummy-locker שלנו כברירת מחדל לקונסטרקטור ריק:

public Counter() : this(new DummyLocker())
{
}

ואז השימוש יהיה קל יותר:

Counter myCounter = new Counter();

נוכל גם להוסיף מתודה סטאטית שתפקידה ליצור instance שהוא thread-safe באופן הבא:

public static Counter Synchronized()
{
    return new Counter(new MonitorLocker());
}

והקריאה:

Counter myCounter = Counter.Synchronized();

סיכום

מה שהצעתי כאן זה אבסטרקציה למנגנון הנעילה, תוך שימוש במאקרו של using כדי לכתוב קוד שמתנהג קרוב ככל האפשר ל lock המוכר.
האבסטרקציה הזו שימושית אם יודעים מראש שיש איזה class שיהיה שימושי גם בסביבה שהיא multi-threaded וגם בסביבה שהיא single-threaded.
עם זאת, יש דרכים נוספות להשיג את התוצאה הזו.
למשל, לכתוב interface ל Counter וליצור decorator שהוא יעטוף כל פעולה בנעילה, או dynamic proxy שיעשה את זה באופן אוטומטי. אולי אני ארחיב על זה בהזדמנות.
בכל מקרה, מה שאנחנו משיגים כאן זו הפרדה של הלוגיקה של הקוד עצמו מהלוגיקה של הנעילה, וזה נחמד לכשעצמו, וגם נותן לנו יתרון משמעותי אם נרצה לכתוב unit testing לקוד הזה.

ניתן להוריד את הקוד של הפוסט הזה מהלינק הזה.

קטגוריות:תכנות תגיות:, , ,

log4net – המדריך למלגלג (חלק 3 – למצוא viewer נורמלי)

12 דצמבר, 2009 רון קליין 10 תגובות

בפוסט הזה:

  • למה צריך viewer ללוג
  • קריטריונים ל viewer נורמלי
  • איזה viewerים קיימים
  • Chainsaw – ה viewer המועדף עלי (מאיפה מורידים, איך מגדירים וכו')

למה צריך Viewer ללוג

אז עשית try/catch (ואולי גם finally), וכתבת ללוג את ה exception. נפלא.
עכשיו מה?
הרי עכשיו, אם אתה יודע שיש איזו שגיאה אי שם בלוג, צריך להתחיל לבדוק מה הסיפור שלה, מה גרם לה להתרחש, מה ומה ומה.
לכל error יש סיפור מאחוריו, עלילה שלמה. בשביל זה צריך viewer – תוכנה שבעזרתה ניתן לראות את הלוג ולנסות להבין את הסיפור.

Log Viewer זו תוכנה די יבשה, שמציגה שורות על גבי שורות, כל שורה היא הודעה ללוג.
הנה כמה תמונות מסך מ viewers שונים:

log4view Kiwi Log Viewer Chainsaw

קריטריונים ל Viewer

כל viewer חייב מערת סינון (filter), כך שמתוך כל ההודעות בלוג יוצגו רק אלו שעונות לתנאי/ם מסויימ/ים.
יהיה נחמד אם ב viewer תהיה גם אפשרות "לקפוץ" להודעה הבאה שמקיימת תנאי מסויים (כמו Find או Search בעורכי טקסט)
יהיה מאוד נחמד לקבל צביעת שורות לפי תנאים מסויימים (לאו דווקא אותם תנאים של הסינון)
אז בואו נפרסם הודעת "דרושים" ל-viewer האידיאלי
לפרויקט עם log4net דרוש viewer לצפיה בלוג:
יודע לקרוא קבצי לוג, גם סגורים וגם פתוחים
יודע לתת חתכי "וגם" (and) – חובה
יודע לתת חתכי "או" (or) – חובה
יודע לתת חתכי טקסט חלקי (like) – חובה
יודע לבצע חיפוש (קפיצות) ע"פ הקריטריונים הנ"ל – יתרון
צביעת שורות על פי תנאים – יתרון
תיעוד טוב – יתרון

אז מה כבר קיים בשוק?

קודם כל, אפשר לכתוב הודעות לוג ל DB. נכון שזה חתיכת overhead לרשום הודעות לוג ל DB, אבל זה אפשרי ב live, ואפשר גם לקחת קובץ לוג, לקרוא אותו, ו"לשפוך" את ההודעות ל DB. מה זה נותן לנו? הרבה כוח לבצע חיתוכים כמה ואיך שאנחנו רוצים. כל מי שהתעסק פעם עם SQL יודע שאפשר ליצור שאילתות פשוטות בזמן קצר. ואפשר להעזר בכל designer כדי לכתוב שאילתות מורכבות יותר. גם ה SQL Management Studio שבא יחד עם MS-SQL-Server עובד יפה.
במילים פשוטות, אם רוצים, אז אפשר לבנות שאילתות מול DB ובאמצעותן לקבל כמעט את כל מה שרוצים. אמנם לא בצבעים יפים, אבל תכלס זה אפשרי ופרקטי.

כמו שסבתא שלי היתה אומרת: נו, וחוץ מזה?

או, אז באמת יש כמה דברים:

אתם מוזמנים לבדוק כל כלי בנפרד. אני בדקתי, ולמרות שמצאתי פיצ'רים חביבים פה ושם, רק Chainsaw עונה על הקריטריון הכי משמעותי מבחינתי: ביצוע חתכי "או". לדוגמה: אני מעוניין לצפות בכל הודעות הלוג שמופיעה בהן המילה "session" ו/או בהודעות הלוג שהגיעו מ class שנקרא "MailSender". כמה טריויאלי, כמה נחוץ, וכמה לא קיים כמעט בשום מקום.

שום מקום חוץ מ Chainsaw, כאמור. הפרויקט הזה, Chainsaw, הוא בכלל ב Java ולמען לוגים בפורמט של log4j. כן, כמו הרבה דברים שקשורים בדוט נט, גם כאן זה התחיל ב Java. אלא מה, הפעם אין שום מקבילה ראויה ל Chainsaw בדוט נט. כך שה look and feel אמנם קצת צולע, אבל הי, חכו תראו איזה מנוע שאילתות מגיע עם הקביים!

Chainsaw – ה Viewer המועדף עלי

הורדות והתקנות

1. הורדות: כדי להריץ את ה Chainsaw הלז צריך שיהיה לכם מותקן על המחשב JRE. וכמובן, צריך להוריד את המסור מהאתר הרשמי של Apache. אני ממליץ להוריד את גרסת ה Unix/Dos Standalone. ה Chainsaw חינמי ברשיון Apache גירסה 2.
2. הורדתם? יופי. עכשיו תתקינו. פשוט לעשות Unzip של גירסת ה Standalone לתיקיה מספיק נוחה לגישה בהארד דיסק. תסלחו לי על הנאיביות, אבל אצלי זה מותקן ב C:\chainsaw-bundle. פשוט ככה, כמו בימי DOS העליזים, כששיחקנו Doom ושאר משחיתי-נוער.
3. התקנתם? יופי, עכשיו תפעילו (פשוט תריצו את הקובץ chainsaw.bat) ומיד תקבלו ניג'וס ראשון "זאת הפעלה ראשונה שלך, בלה-בלה, לא מוגדרים receiver-ים". לא נורא, נגדיר ידנית (ראו תמונה).

ויש עוד ניג'וס כללי: החלון של ה bat – פשוט נמצא שם, מכוער במלוא תפארתו. לא חייבים להשלים עם המונומנט המכוער, אפשר להוריד Launcher ל Java ולעטוף הכל יפה יפה. אני ממליץ על jsmooth (עוד על זה בפוסט נפרד).

הגדרות ב log4net

זה נחמד שמותקן ה Chainsaw, אבל לא מספיק. כמו שציינתי, במקור ה Chainsaw מגיע מעולם ה Java, וזה אומר שהוא מצפה לקרוא את ההודעות בפורמט של log4j. אז כדי שה log4net יוציא הודעות כאלו, צריך לשנות קצת את ההגדרות. אם נתייחס לדוגמה מהפוסט הקודם, אז נשנה את קובץ ה config באופן הבא:

<log4net>
  <appender name="WowItsTheLog4jFileAppender" type="log4net.Appender.FileAppender">
    <file value="mylog.txt" />
    <appendToFile value="true" />
    <layout type="log4net.Layout.XmlLayoutSchemaLog4j" >
      <locationInfo value="true" />
    </layout>
  </appender>

  <root>
    <level value="DEBUG" />
    <appender-ref ref="WowItsTheLog4jFileAppender" />
  </root>
</log4net>

לפני שנחזור ל Chainsaw, נכתוב תוכנית קטנה ש"עובדת קשה" ונותנת הודעות ללוג מכל מיני classים ובת'רדים שונים, כולל exceptions ייזומים. בקיצור, תוכנית שעושה שמח. אני לא ארשום כאן את הקוד של התוכנית, כי זה לא מה שמעניין. מה שמעניין זה איך התוכנית כותבת ללוג ואיך משתמשים ב Chainsaw כדי לצפות בהודעות שמתקבלות. בכל מקרה, התוכנית מצורפת כולל כל ה source.

עובדים עם Chainsaw – למנסרים הידד

עכשיו נחזור ל Chainsaw שלנו. התוכנית שלנו שמרה את הודעות הלוג בקובץ. פשוט נגרור אותו לתוך ה Chainsaw, ואחרי כמה שניות טובות (תלוי כמה המחשב שלכם סוחב Java), הכל נפתח ומוצג. קודם כל, צריך להתרגל קצת למסך הראשי. החלק העיקרי מציג את הודעות הלוג עצמן, עם עמודות מתאימות. העץ שמשמאל מתאר את היררכיית הלוגרים בקונטקסט הנוכחי. לצערנו, גם הלוגרים של ה Chainsaw עצמו מוצגים שם :-( אלא מה, אפשר להעביר את הפוקוס ללוגר הרצוי, ואז יוצגו רק ההודעות הרלוונטיות במסך הראשי.

כדי לבצע שאילתות על ההודעות המוצגות, צריך להשתמש בתחביר של מנוע השאילתות של Chainsaw, ולהקליד באזור של Refine focus on. נטעם קצת ע"י דוגמאות:

MSG ~= 'email' מציג רק את ההודעות שמכילות את המילה email
MSG ~= 'email' && LOGGER ~= 'sender' רק הודעות שמכילות את המילה email ששם הלוגר שלהן מכיל את המילה sender
MSG ~= 'go' || MSG ~= 'before' מציג הודעות שמכילות את המילה go ו/או הודעות שמכילות את המילה before
( LOGGER == 'mylogger' && MSG ~= 'cat' ) || ( THREAD == 1234 ) מציג הודעותשהגיעו מת'רד מספר 1234 ו/או הודעות שמכילות את המילה cat שהגיעו מלוגר שנקרא mylogger
PROP.log4jid >= 400 מציג את כל ההודעות החל משורה 400
LEVEL >= 'warn' מציג רק הודעות מסוג Warn או גבוה ממנו (למשל Error יוצג, אבל Info לא יוצג)

שימו לב שיש רווח לפני ואחרי פתח/סגור סוגריים וכן לפני/אחרי אופרטורים וכד'. בקיצור, צריך רווחים, וה Chainsaw לא סולח ולא שוכח. אם משהו בתחביר השאילתה לא תקין, ה Chainsaw פשוט מתעלם ממנה, ולא מציג שום הודעת שגיאה. כזה הוא, לא משהו ביחס למשתמשים. שיהיה.

קבלת הודעות ב UDP

ב Chainsaw, כמו גם ב viewerים אחרים, יש אפשרות של קבלת הודעות לוג באמצעות תקשורת TCP וכן UDP. כלומר, כמו שה log4net כותב הודעות לוג לקובץ, הוא יכול לשלוח אותם בפרוטוקול TCP או UDP לאן שנרצה. וככה אפשר לצפות בהודעות תוך כדי ריצה של כמה תוכנות במקביל. כשעובדים בסביבה מבוזרת זה פיצ'ר מאוד חזק. אגב, ב UDP לא ניתן לשלוח הודעות לוג ארוכות. מה לעשות, ככה זה.

אז איך?

1. בכל תוכנה רלוונטית, מגדירים ב log4net שליחת הודעות לוג ב UDP:

<appender name="HeyLetsGoWithUdp" type="log4net.Appender.UdpAppender">
  <remoteAddress value="localhost" />
  <remotePort value="48899" />
  <layout type="log4net.Layout.XmlLayoutSchemaLog4j" >
    <locationInfo value="true" />
  </layout>
</appender>

2. מגדירים receiver ב Chainsaw שיאזין להודעות ב UDP באותו פורט שהגדרנו קודם. התמונות הבאות מסבירות את זה:

מוסיפים ומגדירים

זהו.

ועוד כמה דברים על ה Chainsaw

הסקירה כאן היא רק ברמה של היכרות, ויש עוד כמה דברים חביבים ב Chainsaw הפרחח:

אפשר לצבוע שורות לפי אותו מנוע שאילתות, כולל תיעדוף צביעה (במידה שאותה שורה עונה על שני תנאי צביעה שונים). זה פיצ'ר קצת חבוי, אבל מגיעים אליו די מהר.

ניתן לבצע Find

אפשר למיין את ההודעות (המיון הדיפולטי הוא סדר ההודעות כפי שנרשמו ללוג או כפי שהתקבלו ע"י ה Chainsaw, וזה לא בהכרח ה Timestamp שלהן)

הגדרות – מציע לכם לשנות בהגדרות שה Cyclic buffer size יהיה, נניח, 50000. ובאותו מקום אפשר גם להסיר את הסימון מ Confirm Exit.

ה Chainsaw יכול להיתקע בגלל מחסור בזכרון. כדי להתגבר על זה, רצוי להגדיר בקובץ bat הקצאת זיכרון גדולה יותר. פשוט להוסיף את הטקסט -Xms32m -Xmx1024m אחרי ה java. כך שהתוצאה היא

java -Xms32m -Xmx1024m -Dorg.apache.commons.logging.Log=org.apache.commons.logging.impl.Log4JLogger -classpath jakarta-oro-2.0.6.jar;jmdns.jar;log4j-1.3alpha-7.jar;log4j-chainsaw-2.0alpha-1.jar;log4j-optional-1.3alpha-7.jar;log4j-oro-1.3alpha-7.jar;log4j-smtp-1.3alpha-7.jar;log4j-xml-1.3alpha-7.jar;log4j-zeroconf.jar;xstream-1.1.2.jar org.apache.log4j.chainsaw.LogUI

סיכום

זהו, עד כאן לענייני Chainsaw ו log4net. יש, כמובן, כלים נוספים, ויש תשתיות לוג כאלו ואחרות (יש למשל את SmartInspect – אני לא מת על הקונספט שלהם, כי זה להכניס business logic לתוך תשתית הלוג, אבל שווה בדיקה). אני לא מתיימר לקבוע ש log4net טובה יותר מתשתיות אחרות. אבל אני כן חושב ש log4net היא תשתית מצויינת ללוג, עושה את העבודה בצורה טובה, מאפשרת הגדרות מתקדמות כמו סינונים, ומאפשרת הרחבות. בנוסף לכל, log4net היא open source, וזה אומר שגם אם יש באג, אפשר בקלות להכנס לקוד ולראות מה קורה גם בפנים. כדי לצפות בתוצרי הלוג אני משתמש ב Chainsaw, שהוא כלי מצוין לחתכים ולשאילתות, אבל מצריך קצת סבלנות בעבודה.

אם יש להשיג viewer טוב יותר ל log4net – תנו לי פינג.

ועד אז, לגלוג נעים!

קטגוריות:תכנות תגיות:,

log4net – המדריך למלגלג (חלק 2 – הגדרות וקוד)

28 אוקטובר, 2009 ronklein אין תגובות

הרעיון של הפוסט הזה הוא פשוט: מעין cookbook שמסביר איך להתחיל עם log4net מההתחלה, מתוך הנחה שכבר יש לכם Visual Studio 2005 ומעלה (או כל IDE אחר לפיתוח בדוט נט בגירסה 2.0 ומעלה)

אז מה יהיה לנו:

  • הורדה של log4net
  • דוגמה פשוטה של כתיבה ללוג באמצעות log4net ע"י שמירה לקובץ טקסט
  • כתיבה של exception
  • ומה עוד?

מת-חי-לים!

הורדה והתקנה של log4net

דבר ראשון – ההורדה של log4net – כדי להוריד את גירסה 1.2.10 אפשר פשוט ללחוץ כאן. לפרטים נוספים – כאן תמצאו את דף ההורדות של log4net ב Apache.

הורדתם? יופי. עכשיו לעשות unzip לתיקיה חביבה (שתשרת אתכם די הרבה). נניח C:\oss\log4net.

תוכנית ראשונה עם log4net

נמשיך:

ניצור פרוייקט פשוט ב VS, נניח Console Application, ונכתוב בו את ה hello world המפורסם:

static void Main(string[] args)
{
  Console.WriteLine("Hello world");
  Console.ReadLine();
}

עכשיו נכניס פנימה שירותי logging ע"י log4net:

1. נוסיף רפרנס ל log4net תוך שימוש בתיקיה ההיא, לנתיב bin\net\2.0\release\log4net.dll

2. כדי להגדיר את log4net דרך קובץ חיצוני (ולא דרך קוד):

א. נוסיף קובץ app.config (מה שנקרא "Application Configuration File")

ב. נערוך את ה app.config באופן הבא:

<configuration>
    <configSections>
        <section name="log4net" type="System.Configuration.IgnoreSectionHandler"/>
    </configSections>

    <log4net>

        <appender name="OhMyGodItsTheFileAppender" type="log4net.Appender.FileAppender">
            <file value="mylog.txt" />
            <appendToFile value="true" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] – %message%newline" />
            </layout>
        </appender>

        <root>
            <level value="DEBUG" />
            <appender-ref ref="OhMyGodItsTheFileAppender" />
        </root>
    </log4net>
</configuration>

3. כדי ש log4net יתחיל לעבוד ויצא מתרדמת החורף שלו, צריך איזה טריגר שיעיר אותו. אפשר לעשות את זה דרך הקוד, ואפשר בצורה קצת יותר שקופה, ע"י שימוש בקובץ די ביישן בשם AssemblyInfo.cs. זה קובץ שנמצא מתחת ל Properties. שם צריך להוסיף את השורה הבאה (אחרי כל ה using שיש שם, במיקום כלשהו):

[assembly: log4net.Config.XmlConfigurator(Watch = true)]

4. עכשיו, כדי לכתוב ללוג, אנחנו צריכים להשתמש באיזה אובייקט שיתן לנו את שירותי ה logging. את זה עושים, למשל, ע"י הוספת שדה סטטי ל class שלנו (ולכל class שבו נצטרך logging):

א. להוסיף בחלק של ה using את שני הבחורים הבאים (אם אינם):

using System.Reflection;
using log4net;

ב. להוסיף את השדה הסטטי עצמו:

private static readonly ILog Logger = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);

זהו, עכשיו אפשר להשתמש ב logger שלנו. הפעולות 1-3 הנ"ל הן פעולות חד פעמיות לפרויקט שלנו. פעולה מספר 4 חוזרת על עצמה בכל class בפרויקט. הנה קצת תוספות לקוד:

static void Main(string[] args)
{
  Logger.Debug("starting up");
  Console.WriteLine("Hello world");
  Logger.Debug("done");
  Console.ReadLine();
}

נריץ את הפרויקט. ונראה את ה hello world הידוע לשמצה. ואיפה כל ההודעות שרשמנו ללוג? הן נמצאות בתוך הקובץ mylog.txt, שנמצא במיקום של ה exe של הפרוייקט שלנו: בד"כ בנתיב bin\debug או bin\release. אפשר לשנות את שם הקובץ mylog.txt לכל שם אחר. ויש עוד הרבה הגדרות, לא לדאוג…

בשלב זה יש לנו תוכנית עם logger, שמבצעת כתיבות ללוג, שלמעשה נשמרות לקובץ. זה הבסיס ל-log4net. זה המתכון, אם תרצו, להוספת log4net לפרוייקט שלכם בצורה יחסית פשוטה ופורטבילית.

כתיבת exception ללוג

לכתוב exception ללוג זה לא סיפור גדול: זה כמעט אותו הדבר כמו כתיבה רגילה, רק משתמשים בחתימה שכוללת אובייקט מסוג Exception. מן הסתם, זה יהיה בתוך try/catch. הנה דוגמה קטנה:

static void Main(string[] args)
{
  Logger.Debug("starting up");
  string fileName = "file-does-not-exist.txt";
  try
  {
    string contents = System.IO.File.ReadAllText(fileName);
  }            
  catch (Exception ex)
  {
    Logger.Error("cannot read contents of file " + fileName, ex);
    Console.WriteLine("oops, an error occured. see log for details");
  }

  Logger.Debug("done");
  Console.ReadLine();
}

מומלץ מאוד להשתמש במתודות עם חתימת ה Exception, כי ה exception נשמר קצת אחרת, וזה מאפשר לבצע חתכים אחרים ולתצוגה שונה דרך ה viewer (בפוסט הבא).

לאן ממשיכים מכאן

אפשר לכתוב ל-EventLog. שימו לב שזה דורש הרשאות גבוהות יחסית.

אפשר לכתוב ל-Trace ולעקוב אחריו עם כלים חיצוניים כמו DebugView של SysInternals. זה שקול ל-System.Diagnostics.Trace.WriteLine

ואפשר עוד הרבה דברים, כמו לכתוב ל DB, לכתוב ל TCP, ל UDP, לשלוח מייל ועוד. גשו לדף הדוגמאות ב Apache ותהנו.

אגב, לפי ההגדרות שבפוסט הזה, אפשר לשנות בזמן ריצה את ההגדרות של ה log4net – וההתנהגות של ה logging תשתנה בהתאם. מאגניביישן.

לסיכום, זה פוסט שכל המטרה שלו היא לתת מתכון פשוט לשימוש ב log4net. בפוסט הבא נראה איך אפשר לנתח את הלוגים, ע"י viewer כמו Chainsaw.

לגלגו ותהנו :-)

פרויקט דוגמה

קטגוריות:תכנות תגיות:

log4net – המדריך למלגלג (חלק 1 – מבוא)

23 אוקטובר, 2009 ronklein אין תגובות

בפוסט הזה:

  • מבוא
  • למה בכלל לכתוב ללוג?
  • סוגי הודעות לפי רמות חוּמרה
  • מה כותבים ללוג

מבוא

חלק בלתי נפרד מאפליקציה רצינית הוא הלוג – שירות שמאפשר כתיבת הודעות.
בזמן שהאפליקציה חיה ונושמת היא יכולה לכתוב הודעות שונות ללוג. ההודעות יכולות להיות בסגנון "עכשיו מתבצע כך וכך" או "יש כאן שגיאה לא צפויה".
הלוג עצמו יכול להישמר כקובץ, או קבצים, או כרשומות ב DB.
או שהלוג יכול לא להישמר כלל, אלא רק סוג של Console.WriteLine או Debug.WriteLine או Trace.WriteLine.
או שהלוג שולח את ההודעות באמצעות TCP או UDP למקום אחר.
או שהלוג שולח מייל למישהו…
בקיצור, יש את העניין של לכתוב ללוג ("יש כאן שגיאה לא צפויה"), ויש את העניין של מה תהיה התוצאה של הכתיבה ללוג (ההודעות נשמרות/מוצגות וכד').
בנוסף לכל זה, גם אם כתבנו ללוג והכל טוב ויפה, נרצה אח"כ גם לצפות בתוצאה, ולעשות חיתוכים שונים. במילים אחרות, נרצה איזה Viewer – תוכנה נורמלית עם UI חביב שתאפשר לנו את התצוגה והחיתוכים.
אה, ועוד משהו. נרצה גם לוג מספיק חכם כך שאם נרצה לשנות את ההגדרות שלו לא נצטרך להוריד את האפליקציה ולטעון אותה מחדש.

אז מה היה לנו: הודעות ללוג ואיך הן "נכתבות", תוכנת viewer, טעינה חכמה אחרי שינוי ההגדרות.
כל זה ניתן למימוש בקלות עם log4net – תשתית מוכחת ועובדת ללוג, שהיא open source. אבל לפני הכל, עוד קצת מבוא.

למה בכלל לכתוב ללוג?

שאלה טובה.

לא חייבים.

אבל הנסיון שלי מראה שכתיבה מושכלת ללוג מאפשרת למפתחים להבין באגים (ולפתור אותם) מהר יותר, בהשפעה אפסית על הביצועים.

בנוסף, קהל היעד של הלוג הוא לא רק מפתחים. גם אנשי IT או אנשים שמתחזקים את האפליקציה יכולים להעזר בו.

בשורה התחתונה, כתיבה ללוג היא גם כדי לוודא שהאפליקציה עובדת כמצופה וגם כדי לתעד מצבים לא תקינים ואת אפשרויות הטיפול בהם.

סוגי הודעות לפי רמות חוּמרה

רגע לפני שמתחילים, כמה מילים על ההודעות השונות שאנחנו מכניסים ללוג.

ב log4net, ולא רק שם, ההודעות ללוג מתחלקות לסוגים הבאים:

  • Debug
  • Info
  • Warn
  • Error
  • Fatal

נרחיב קצת…

הודעות Debug (ורק הן) מיועדות למפתחים עצמם, ואפשר להשתולל איתן כמה שרוצים. כפי שנראה מאוחר יותר, אפשר לשנות את ההגדרות כך ש log4net יתעלם מהן לחלוטין. בד"כ כותבים ל Debug הודעות כמו "עכשיו לפני פתיחת חיבור ל DB" ו"התחברתי בהצלחה ל DB" וכו'. בקיצור, אבני דרך למפתחים עצמם.

הודעות Info מכילות מידע מתומצת על המצב של האפליקציה, שהוא בחזקת "טוב לדעת". לדוגמה, כמעט כל service (או console שמדמה service) שכתבתי בדוט נט קורא את הקונפיגורציה ומיד אח"כ כותב הודעת info ללוג בנוסח "שירות xyz עלה בהצלחה עם ההגדרות הבאות: …".

הודעות Warn מתייחסות למקרים שבהם האפליקציה נתקלה ב exception או במצב לא תקין, אבל היא יודעת להתאושש ממנו. למשל, המערכת שלנו לא מצליחה להוציא מייל כרגע. לא נורא, היא תנסה שוב עוד דקה.

הודעות Error מתייחסות למקרים שבהם האפליקציה נתקלת ב exception או במצב לא תקין והיא לא יודעת להתאושש ממנו. זה יכול להשפיע רק על המשתמש הנוכחי (נניח אם זו אפליקציית web) וזה יכול להיות משהו יותר תשתיתי.

הודעות Fatal מתייחסות למקרי קצה שבהן האפליקציה שלנו לא יכולה להתאושש ממשהו לא תקין וכדאי שמישהו יסדר את זה בהקדם האפשרי. כלומר יש כאן גם הנחיה לגבי ניתוח הלוג וטיפול בשגיאות. הודעות Fatal צריכות להיות בודדות כדי לא ליצור מצב של "זאב-זאב".

מה כותבים ללוג

אם אתם לוקחים אתכם משהו מהפוסט הזה – קחו את זה: לא רק כותבים ללוג "היתה כאן שגיאה" ומצרפים את האובייקט של ה exception. כותבים את כל הקונטקסט הרלוונטי כדי שאח"כ נוכל להבין טוב יותר מה קרה. למשל "לא הצלחתי לקרוא את התוכן של הקובץ X כאשר הבקשה היתה Y" בצירוף ה exception. כן, זה לוקח עוד דקה, אבל זה כל כך שווה את זה.

אלא שלפעמים, מטעמי security או privacy לא כדאי לכתוב ממש הכל. למשל, "לא הצלחתי להתחבר ל SQL Server שנמצא בכתובת X עם שם משתמש U וסיסמה P" נשמע לי רעיון לא טוב, כי זה חושף את פרטי ההתחברות ל DB כולל הסיסמה. אפשר אולי במקום לכתוב את הסיסמה לכתוב את ה hash שלה לפי הדוט נט (GetHashCode), או לפי סטנדרט חזק יותר כמו MD5, כאשר כותבים את ערך ה hash ב base64 (וגם אז, אפשר לכתוב רק את N התוים הראשונים מטעמי חסכון ונוחות קריאה).

זהו, עד כאן המבוא. בפוסטים הבאים – איך משתמשים ב log4net כדי לכתוב ללוג, איזה viewer-ים קיימים ועוד.

קטגוריות:תכנות תגיות: