Odczytywanie i analizowanie wyjątków Java

Question

Mam mały system i chcę zaoferować produkt, który może analizować błędy/wyjątki i sugerować możliwe rozwiązanie.

Tak więc chcę sposób analizować wyjątek Java (ponieważ mam je tylko w dziennikach [nie chcę wpływać na rzeczywisty system]).

Po przeanalizowaniu, chcę zapisać go w DB i porównać z wcześniej zapisanymi wyjątkami (w pewnym formacie), aby znaleźć najbliższy pasujący wyjątek.

Pomyślałem o następującym pomyśle: "XException na A w B na C na D" zostanie zapisany jako [XException, A, B, C, D] i będę jakoś szukał w moim DB: [XException ,?,?,?], który jest najbliższy. Na przykład: [XException, A, G, C, D] jest całkiem niezły.

Co sądzisz o tych pomysłach?

Dowolny skuteczny sposób analizowania Wyjątki?

Wydajne lub lepsze sposoby określania odległości między dwoma wyjątkami?

Znać wszelkie otwarte źródła, które mogą to zrobić - nie znalazłem żadnych.

Dziękuję.

Answer 1

To dość ciężka praca, ale tutaj jest demonstracja analizowania rzeczywistych wyjątków generowanych w locie.

• Metoda nazywa się generate_ $, aby spróbować i objąć dziwnie nazwane metody. Jestem pewien, że nie omówiłem wszystkich przypadków.
• zrekonstruuj je z powrotem na listę java.lang.StackTraceElement, ponieważ wydaje się być właściwym typem dla zadania.

Kod:

private static List<String> generate_$() { 
    List<String> returnValue = new LinkedList<String>(); 
    Exception[] exceptions = { new ClassCastException(), 
      new NullPointerException(), new IOException("foo") }; 
    for (Exception exception : exceptions) { 
     try { 
      throw exception; 
     } catch (Exception e) { 
      StringWriter writer = new StringWriter(); 
      e.printStackTrace(new PrintWriter(writer)); 
      returnValue.add(writer.getBuffer().toString()); 
     } 
    } 
    return returnValue; 
} 

public static void main(String[] args) { 
    List<String> examples = generate_$(); 
    for (String trace : examples) { 
     Pattern headLinePattern = Pattern.compile("([\\w\\.]+)(:.*)?"); 
     Matcher headLineMatcher = headLinePattern.matcher(trace); 
     if (headLineMatcher.find()) { 
      System.out.println("Headline: " + headLineMatcher.group(1)); 
      if (headLineMatcher.group(2) != null) { 
       System.out.println("Optional message " 
         + headLineMatcher.group(2)); 
      } 
     } 
     // "at package.class.method(source.java:123)" 
     Pattern tracePattern = Pattern 
       .compile("\\s*at\\s+([\\w\\.$_]+)\\.([\\w$_]+)(\\(.*java)?:(\\d+)\\)(\\n|\\r\\n)"); 
     Matcher traceMatcher = tracePattern.matcher(trace); 
     List<StackTraceElement> stackTrace = new ArrayList<StackTraceElement>(); 
     while (traceMatcher.find()) { 
      String className = traceMatcher.group(1); 
      String methodName = traceMatcher.group(2); 
      String sourceFile = traceMatcher.group(3); 
      int lineNum = Integer.parseInt(traceMatcher.group(4)); 
      stackTrace.add(new StackTraceElement(className, methodName, 
        sourceFile, lineNum)); 
     } 
     System.out.println("Stack: " + stackTrace); 

    } 
} 

wyjściowa:

Headline: java.lang.ClassCastException 
Stack: [com.adamish.ExceptionParse.generate_$((ExceptionParse.java:16), com.adamish.ExceptionParse.main((ExceptionParse.java:31)] 

Headline: java.lang.NullPointerException 
Stack: [com.adamish.ExceptionParse.generate_$((ExceptionParse.java:17), com.adamish.ExceptionParse.main((ExceptionParse.java:31)] 

Headline: java.io.IOException 
Optional message : foo 
Stack: [com.adamish.ExceptionParse.generate_$((ExceptionParse.java:17), com.adamish.ExceptionParse.main((ExceptionParse.java:31)] 

Answer 2

Myślę, że to pytanie zostanie zamknięte jako zbyt otwarte. SO jest przeznaczony do pytań, na które można udzielić jasnych i jednoznacznych odpowiedzi.

Mimo to, zanim to się stanie, chciałbym powiedzieć, że wydaje się to całkiem niezłym pomysłem i mam nadzieję, że uda się to sprawić. Najlepiej byłoby skupić się na tych częściach śladu stosu, które wyraźnie identyfikują niezmienne informacje, takie jak nazwy paczek, klas i metod. Jeśli chodzi o wykrywanie częściowych lub kompletnych dopasowań, sugeruję zapoznanie się ze znanymi algorytmami indeksowania i dopasowywania. Można zastosować niektóre dobrze znane algorytmy do wyszukiwania tekstu, ale zamiast jednostek "atomowych" są to nazwy metod lub nazw klas pakowanych, jeśli są pojedynczymi literami lub słowami.

Powodzenia!

EDYCJA: pomyśleliśmy o czymś innym. Możesz skupić się na możliwie jak największej implementacji implementacji dla śladów stosu wielu różnych języków programowania, frameworków itp. To sprawi, że oprogramowanie będzie bardziej przyszłościowe i będzie miało szerokie zastosowanie.