webroar 0.4.0 → 0.5.0

data/src/helper/wr_yaml_parser.c

@@ -24,214 +24,126 @@
 #include <stdlib.h>
 #include <assert.h>
 #include <wr_yaml_parser.h>
+#include <wr_stack.h>
 #include <wr_logger.h>
 
-/** Free node */
-void node_free(node_t* node) {
-
-  if(node == NULL)
-    return;
-
-  //Free child
-  if(node->child) {
-    node_free(node->child);
-  }
-
-  // Free siblings
-  if(node->next) {
-    node_free(node->next);
-  }
-
-  if(node->name) {
-    free(node->name);
-    node->name = NULL;
-  }
-  if(node->value) {
-    free(node->value);
-    node->value = NULL;
-  }
-
-  free(node);
-  node = NULL;
+node_t* create_node() {
+  node_t *node = (node_t*) malloc(sizeof(node_t));
+  node->child = node->next = NULL;
+  node->key = node->value = NULL;
+  node->key_len = node->value_len = node->level = 0;
+  node->type = TYPE_NONE;
+  return node;
 }
 
-/** Fetch node value */
-char* get_node_value(node_t *root, char* xpath) {
-  char *str_ptr, *str_prev;
-  node_t *node = root, *result;
-  int len;
-
-  str_prev = xpath;
-  str_ptr = strchr(xpath,'/');
-
-  //Find first match
-  while(str_ptr) {
-    len = str_ptr - str_prev;
-    result = NULL;
-    while(node) {
-      if(node->name_len == len && strncmp(str_prev, node->name, len)==0) {
-        result = node;
-        break;
-      }
-      node = node->next;
-    }
+/** Parse YAML file */
+node_t* yaml_parse(const char*file_name) {
+  FILE *file;
+  yaml_parser_t parser;
+  yaml_event_t event;
+  node_t *node = NULL, *new, *head_node;
+  int level = 0, done = 0;
+  wr_stack_t stack;
 
-    if(!result) {
-      return NULL;
+  void create_child_node() {
+    new = create_node();
+    new->level = ++level;
+    if (node) {
+      wr_stack_push(&stack, node);
+      node->child = new;
     }
-
-    node = result->child;
-
-    str_prev = str_ptr + 1;
-    str_ptr = strchr(str_prev,'/');
+    node = new;
   }
 
-  while(node) {
-    if(strcmp(str_prev, node->name) == 0) {
-      return node->value;
+  void set_sibling_nodes() {
+    head_node = (node_t*) wr_stack_pop(&stack);
+    while (head_node && head_node->level == level) {
+      head_node->next = node;
+      node = head_node;
+      head_node = (node_t*) wr_stack_pop(&stack);
     }
-    node = node->next;
-  }
-
-  return NULL;
-}
-
-/** Fetch set of nodes */
-node_t* get_nodes(node_t *root, char* xpath) {
-  char *str_ptr;
-  node_t *node = root, *node_front, *node_rear, *result;
-  int len;
-
-  str_ptr = strchr(xpath,'/');
-  node_front = node_rear = NULL;
-  if(str_ptr) {
-    len = str_ptr - xpath;
-    node_front = node_rear = NULL;
-
-    while(node) {
-      if(node->name_len == len && strncmp(xpath, node->name, len)==0) {
-        //Recursive call to match child nodes
-        result = get_nodes(node->child, str_ptr+1);
-        if(result) {
-          if(!node_front)
-            node_front = result;
-          if(node_rear)
-            node_rear->next_result = result;
-          while(result->next_result) {
-            result = result->next_result;
-          }
-          node_rear = result;
-        }
-      }
-      node = node->next;
+    if (head_node) {
+      wr_stack_push(&stack, head_node);
     }
-  } else {
-    while(node) {
-      if(strcmp(xpath, node->name)==0) {
-        if(node_rear)
-          node_rear->next_result = node;
-        node_rear = node;
-        if(!node_front)
-          node_front = node;
-        node->next_result = NULL;
+    level--;
+    if (head_node) {
+      if (head_node->child != node) {
+        new = create_node();
+        new->level = level;
+        new->type = head_node->type;
+        new ->child = node;
+        wr_stack_push(&stack, new);
       }
-      node = node->next;
+      node = NULL;
     }
   }
-  return node_front;
-}
 
-/** Parse YAML file */
-node_t* yaml_parse(const char*file_name) {
-  FILE *file;
-  yaml_parser_t parser;
-  yaml_event_t event;
-  node_t *node, *config = NULL, *prev;
-  int done = 0, is_key = 0, seq_count = -1, is_seq = 0;
-  char seq[10][100];
-  node_t* stack[100];
-  int head = -1;
+  void create_scalar_node() {
+    if (node) {
+      wr_stack_push(&stack, node);
+    }
 
+    node = create_node();
+    if (head_node = (node_t*) wr_stack_pop(&stack)) {
+      node->type = head_node->type;
+      wr_stack_push(&stack, head_node);
+    } else {
+      node->type = TYPE_NONE;
+    }
+    node->level = level;
+    STR_NEW(node->key, event.data.scalar.value, event.data.scalar.length);
+    node->key_len = event.data.scalar.length;
+  }
 
   file = fopen(file_name, "rb");
   assert(file);
 
   assert(yaml_parser_initialize(&parser));
   yaml_parser_set_input_file(&parser, file);
+  wr_stack_init(&stack);
 
-  while(!done) {
-    if(!yaml_parser_parse(&parser, &event)) {
-      perror("yaml_parser_parse()");
+  while (!done) {
+    if (!yaml_parser_parse(&parser, &event)) {
+      perror("Invalid YAML format.");
       break;
     }
 
-    switch(event.type) {
+    switch (event.type) {
 
+    case YAML_NO_EVENT:
+      printf("\nYAML_NO_EVENT");
+      break;
     case YAML_STREAM_END_EVENT:
       done = 1;
       break;
-    case YAML_SCALAR_EVENT:  //Handle Scalar event
-      is_key = (is_key == 0);
-      if(head != -1) {
-        if(is_key) {
-          STR_NEW(stack[head]->name, event.data.scalar.value, event.data.scalar.length)
-          stack[head]->name_len = event.data.scalar.length;
-        } else {  // Copy value and create next node
-          STR_NEW(stack[head]->value, event.data.scalar.value, event.data.scalar.length)
-          stack[head]->value_len = event.data.scalar.length;
-          node = stack[head--];
-          prev = node;
-          NODE_NEW(node->next)
-          stack[++head] = node->next;
-        }
-      }
-      break;
-    case YAML_MAPPING_START_EVENT:  //Handle Mapping Start event
-      if(config) {
-        node = stack[head];
-        NODE_NEW(node->child)
-        stack[++head] = node->child;
+    case YAML_SCALAR_EVENT:
+      if (node == NULL) {
+        create_scalar_node();
+      } else if (node->key == NULL) {
+        STR_NEW(node->key, event.data.scalar.value, event.data.scalar.length);
+        node->key_len = event.data.scalar.length;
+      } else if (node->type == TYPE_LIST) {
+        create_scalar_node();
+      } else if (node->value == NULL) {
+        STR_NEW(node->value, event.data.scalar.value, event.data.scalar.length);
+        node->value_len = event.data.scalar.length;
       } else {
-        NODE_NEW(config)
-        stack[++head] = config;
-      }
-      //if(!is_seq && is_key){
-      //strcpy(map[map_count++], key);
-      //printf("\n\n>>> Map:%s >>>",map[map_count-1]);
-      is_key = 0;
-      //}
-      break;
-    case YAML_MAPPING_END_EVENT:  //Handle Mapping End event
-      if(head != -1) {
-        node = stack[head--];
-        if(prev->next->name)
-          free(prev->next->name);
-        if(prev->next->value)
-          free(prev->next->value);
-        free(prev->next);
-        prev->next = NULL;
-      }
-      if(head != -1) {
-        node = stack[head--];
-        prev = node;
-        NODE_NEW(node->next)
-        stack[++head] = node->next;
-      }
-      if(is_seq && seq_count >= 0) {
-        STR_NEW(stack[head]->name, seq[seq_count], strlen(seq[seq_count]))
-        stack[head]->name_len = strlen(seq[seq_count]);
-        //printf("\n<<< Map:%s <<<\n",map[--map_count]);
+        create_scalar_node();
       }
       break;
     case YAML_SEQUENCE_START_EVENT:
-      is_seq ++;
-      strcpy(seq[++seq_count], stack[head]->name);
-      is_key = 0;
+      create_child_node();
+      node->type = TYPE_LIST;
       break;
     case YAML_SEQUENCE_END_EVENT:
-      if(seq_count >= 0)
-        seq_count--;
-      is_seq --;
+      set_sibling_nodes();
+      break;
+    case YAML_MAPPING_START_EVENT:
+      create_child_node();
+      node->type = TYPE_ARRAY;
+      break;
+    case YAML_MAPPING_END_EVENT:
+      set_sibling_nodes();
       break;
     }
 
@@ -241,39 +153,139 @@ node_t* yaml_parse(const char*file_name) {
   yaml_parser_delete(&parser);
   assert(!fclose(file));
 
-  if(done) {
-    return config;
+  if (done) {
+    head_node = (node_t*) wr_stack_pop(&stack);
+    if (head_node && !stack.list) {
+      return head_node;
+    } else if (node) {
+      wr_stack_free(&stack);
+      return node;
+    }
   } else {
-    node_free(config);
-    return NULL;
+    head_node = (node_t*) wr_stack_pop(&stack);
+    while (head_node && stack.list) {
+      wr_stack_push(&stack, head_node);
+      set_sibling_nodes();
+      head_node = (node_t*) wr_stack_pop(&stack);
+    }
+    yaml_node_free(node);
+    if (head_node) {
+      yaml_node_free(head_node);
+    }
+  }
+
+  return NULL;
+}
+
+/** Display YAML Structure */
+void yaml_display(node_t * root) {
+
+  if (root == NULL)
+    return;
+  printf("\n%*s", root->level * 4, " ");
+  if (root->type == TYPE_LIST)
+    printf("-  ");
+  if (root->key)
+    printf("%s", root->key);
+  if (root->value)
+    printf(": %s", root->value);
+  yaml_display(root->child);
+  yaml_display(root->next);
+}
+
+void yaml_node_free(node_t* node) {
+  if (node == NULL)
+    return;
+
+  if (node->next) {
+    yaml_node_free(node->next);
+    node->next = NULL;
+  }
+
+  if (node->child) {
+    yaml_node_free(node->child);
+    node->child = NULL;
   }
+
+  if (node->key)
+    free(node->key);
+  if (node->value)
+    free(node->value);
+
+  free(node);
+}
+
+/** Search node */
+node_t* yaml_get_node(node_t *root, char *xpath) {
+  char *str_ptr;
+  node_t *node = root, *result = NULL;
+  int len;
+
+  str_ptr = strchr(xpath, '/');
+  if (str_ptr) {
+    len = str_ptr - xpath;
+
+    if (len == 1 && xpath[0] == '*') {
+      while (node && !result) {
+        result = yaml_get_node(node->child, str_ptr + 1);
+        node = node->next;
+      }
+    } else {
+      while (node && !result) {
+        if (node->key_len == len && strncmp(xpath, node->key, len) == 0) {
+          result = yaml_get_node(node->child, str_ptr + 1);
+        }
+        node = node->next;
+      }
+    }
+  } else if (strcmp(xpath, "*") == 0) {
+    result = node;
+  } else {
+    while (node) {
+      if (node->key && strcmp(xpath, node->key) == 0) {
+        result = node;
+        break;
+      }
+      node = node->next;
+    }
+  }
+  return result;
+}
+
+/** Search node and get value */
+char* yaml_get_value(node_t *root, char* xpath) {
+  node_t *result = yaml_get_node(root, xpath);
+  if (result && result->value) {
+    return result->value;
+  }
+  return NULL;
 }
 
 /** Validate YAML tokens */
-char* wr_validate_string(const char* str) {
+char* yaml_validate_string(const char* str) {
   int count, len, is_blank, is_comment;
 
-  if(str == NULL)
+  if (str == NULL)
     return NULL;
 
   //Set flags
   is_blank = 1;
   is_comment = 0;
   len = strlen(str);
-  for(count = 0; count < len ; count++) {
+  for (count = 0; count < len; count++) {
     //check for blank value
-    if(str[count] != ' ') {
+    if (str[count] != ' ') {
       is_blank = 0;
     }
     //check for comment '#' character
-    if(str[count] == '#') {
+    if (str[count] == '#') {
       is_comment = 1;
       break;
     }
   }
-  if(is_comment || is_blank) {
+  if (is_comment || is_blank) {
     LOG_ERROR(SEVERE,"Invalid token.");
     return NULL;
   }
-  return (char*)str;
+  return (char*) str;
 }

data/src/helper/wr_yaml_parser.h

@@ -23,6 +23,8 @@
 /**
  * Parse the YAML file and generate node tree.
  * These node tree used by 'configurator' module.
+ *
+ * NOTE: Anchors and Aliases are not handled.
  */
 
 #ifndef WR_YAML_PARSER_H_
@@ -32,37 +34,40 @@
 #include <string.h>
 
 /** Macro definitions */
-#define NODE_NEXT(node) node->next_result
-#define NODE_VALUE(node) node->value
 
-#define STR_NEW(new, str, len) new = (char*) malloc(sizeof(char)*(len+1));\
-  strcpy(new, str);
+#define STR_NEW(new, str, len) do { new = (char*) malloc(sizeof(char)*(len+1));\
+  strcpy(new, str); } while(0);
 
-#define NODE_NEW(node) node = (node_t*) malloc(sizeof(node_t));\
-  node->name = NULL;\
-  node->name_len =0;\
-  node->value = NULL;\
-  node->value_len = 0;\
-  node->child = NULL;\
-  node->next = NULL;\
-  node->next_result = NULL;
+typedef enum type_e {
+  TYPE_NONE = 0, TYPE_VALUE, TYPE_PAIR, TYPE_LIST, TYPE_ARRAY
+} type_t;
 
 typedef struct node_s node_t;
 
 struct node_s {
-  char* name;    /**< Node name */
-  int name_len;  /**< Name length */
-  char* value;  /**< Node value */
-  int value_len;  /**< Value length */
-  node_t* next;  /**< Pointer to sibling */
-  node_t* child;  /**< Pointer to child nodes*/
-  node_t* next_result;  /**< Pointer used by 'get_nodes' method*/
+  type_t type;
+  char *key, *value;
+  int key_len, value_len;
+  short level;
+  node_t *child, *next;
 };
 
+/** Print YAML structure */
+void yaml_display(node_t *);
+
+/** Parse the YAML file and create node structure */
 node_t* yaml_parse(const char*);
-node_t* get_nodes(node_t *root, char* xpath);
-char* get_node_value(node_t *root, char* xpath);
-void node_free(node_t* node);
-char* wr_validate_string(const char* str);
+
+/** Release node memory */
+void yaml_node_free(node_t*);
+
+/** Search node */
+node_t* yaml_get_node(node_t *root, char *xpath);
+
+/** Search node and get value */
+char* yaml_get_value(node_t *root, char* xpath);
+
+/** Validate YAML token */
+char* yaml_validate_string(const char* str);
 
 #endif /*WR_YAML_PARSER_H_*/

data/src/ruby_lib/analyzer/db_connect.rb

@@ -38,7 +38,7 @@ module Webroar
       end
       
       def self.load_models      
-        models = Dir.glob(File.join(ADMIN_PANEL_ROOT, 'app', 'models', "{app,url_breakup_time_sample,app_time_sample,resource_usage,url_time_sample,app_exception}.rb"))
+        models = Dir.glob(File.join(ADMIN_PANEL_ROOT, 'app', 'models', "{app,url_breakup_time_sample,app_time_sample,resource_usage,url_time_sample,app_exception,exception_detail}.rb"))
         unloaded = Array.new
         models.each do |f|
           begin

data/src/ruby_lib/analyzer/message_analyzer.rb

@@ -152,6 +152,16 @@ module Webroar
         end
       end
       
+      # This method is used to check the class of incomming exceptions
+      # whether class is included in permanently ignored list or not.
+      def in_permanently_ignored_list?(app_name,class_type)
+        info = YAML::load_file("#{WEBROAR_ROOT}/conf/config.yml") rescue nil
+        app_data = info['Application Specification'].detect{|app_item| app_item["name"].eql?(app_name)}
+        if app_data["permanently_ignored_list"]
+          app_data["permanently_ignored_list"].include?(class_type)
+        end
+      end
+
       def process_exceptions
         begin 
           exception_hash = @message_reader.read_exception()
@@ -170,40 +180,61 @@ module Webroar
                   exception = AppException.find(:first,:conditions=>["exception_message=? and app_id=?",exception_hash[:exception_message],app_id])
                 end
               end
-              if exception 
+              if exception
                 status = exception.exception_status.to_i
+                # if its class is in Permanently ignored list , change status as PERMANENTLY_IGNORED_EXCEPTION
+                if(in_permanently_ignored_list?(app_name,exception_hash[:exception_class]))
+                  status = PERMANENTLY_IGNORED_EXCEPTION
+                  with_exception_handling("Exception entry - Update existing entry status to PERMANENTLY_IGNORED_EXCEPTION") do
+                    exception.exception_status = PERMANENTLY_IGNORED_EXCEPTION
+                    exception.save!
+                  end
+                end
                 if status == CLOSED_EXCEPTION
+                  # if its been closed, mark entry as open
                   status = OPEN_EXCEPTION
-                  # if its been closed, mark each entry as open
-                  exceptions = nil
-                  with_exception_handling("Exception entry - Update existing entries status to OPEN") do
-                    AppException.update_status_to(status, app_id, exception_hash[:exception_message])                    
+                  with_exception_handling("Exception entry - Update existing entry status to OPEN") do
+                    exception.exception_status = OPEN_EXCEPTION
+                    exception.save!
                   end                 
                 end
               else
-                # New exception,  set it as Open
-                status = OPEN_EXCEPTION
+                # New exception,  set it as PERMANENTLY_IGNORED_EXCEPTION if exception class falls into
+                # PERMANENTLY_IGNORED_LIST otherwise set it as Open
+                if(in_permanently_ignored_list?(app_name,exception_hash[:exception_class]))
+                  status = PERMANENTLY_IGNORED_EXCEPTION
+                else
+                  status = OPEN_EXCEPTION
+                end
+                with_exception_handling("Exception entry AppException.create") do
+                  exception = AppException.create({:app_id => app_id,  :exception_message => exception_hash[:exception_message],
+                                       :exception_class => exception_hash[:exception_class], :exception_status => status})                                     
+
+                end
               end
               with_exception_handling("Exception entry AppException.create") do
-                AppException.create({:app_id => app_id, :app_env => exception_hash[:app_env], :controller => exception_hash[:controller],
-                                      :method => exception_hash[:method], :exception_message => exception_hash[:exception_message],
-                                      :exception_class => exception_hash[:exception_class], :exception_backtrace => exception_hash[:exception_backtrace],
-                                      :exception_status => status, :wall_time => exception_hash[:wall_time], :chunked => exception_hash[:chunked],
-                                      :content_length => exception_hash[:content_length], :http_accept => exception_hash[:http_accept],
-                                      :http_accept_charset => exception_hash[:http_accept_charset], :http_accept_encoding => exception_hash[:http_accept_encoding],
-                                      :http_accept_language => exception_hash[:http_accept_language], :http_connection => exception_hash[:http_connection],
-                                      :http_cookie => exception_hash[:http_cookie], :http_host => exception_hash[:http_host], 
-                                      :http_keep_alive => exception_hash[:http_keep_alive], :http_user_agent => exception_hash[:http_user_agent],
-                                      :http_version => exception_hash[:http_version], :path_info => exception_hash[:path_info],
-                                      :query_string => exception_hash[:query_string], :remote_addr => exception_hash[:remote_addr],
-                                      :request_method => exception_hash[:request_method], :request_path => exception_hash[:request_path],
-                                      :request_uri => exception_hash[:request_uri], :script_name => exception_hash[:script_name],
-                                      :server_name => exception_hash[:server_name], :server_port => exception_hash[:server_port],
-                                      :server_protocol => exception_hash[:server_protocol], :server_software => exception_hash[:server_software],
-                                      :rack_errors => exception_hash[:rack_errors], :rack_input => exception_hash[:rack_input],
-                                      :rack_multiprocess => exception_hash[:rack_multiprocess], :rack_multithread => exception_hash[:rack_multithread],
-                                      :rack_run_once => exception_hash[:rack_run_once], :rack_url_scheme => exception_hash[:rack_url_scheme],
-                                      :rack_version => exception_hash[:rack_version]})                
+                exception.exception_details.create({
+                        :app_env => exception_hash[:app_env], :controller => exception_hash[:controller],
+                        :method => exception_hash[:method],
+                        :exception_backtrace => exception_hash[:exception_backtrace],
+                         :wall_time => exception_hash[:wall_time], :chunked => exception_hash[:chunked],
+                        :content_length => exception_hash[:content_length], :http_accept => exception_hash[:http_accept],
+                        :http_accept_charset => exception_hash[:http_accept_charset], :http_accept_encoding => exception_hash[:http_accept_encoding],
+                        :http_accept_language => exception_hash[:http_accept_language], :http_connection => exception_hash[:http_connection],
+                        :http_cookie => exception_hash[:http_cookie], :http_host => exception_hash[:http_host], 
+                        :http_keep_alive => exception_hash[:http_keep_alive], :http_user_agent => exception_hash[:http_user_agent],
+                        :http_version => exception_hash[:http_version], :path_info => exception_hash[:path_info],
+                        :query_string => exception_hash[:query_string], :remote_addr => exception_hash[:remote_addr],
+                        :request_method => exception_hash[:request_method], :request_path => exception_hash[:request_path],
+                        :request_uri => exception_hash[:request_uri], :script_name => exception_hash[:script_name],
+                        :server_name => exception_hash[:server_name], :server_port => exception_hash[:server_port],
+                        :server_protocol => exception_hash[:server_protocol], :server_software => exception_hash[:server_software],
+                        :rack_errors => exception_hash[:rack_errors], :rack_input => exception_hash[:rack_input],
+                        :rack_multiprocess => exception_hash[:rack_multiprocess], :rack_multithread => exception_hash[:rack_multithread],
+                        :rack_run_once => exception_hash[:rack_run_once], :rack_url_scheme => exception_hash[:rack_url_scheme],
+                        :rack_version => exception_hash[:rack_version]
+                        })                                     
+                         
               end            
               
               if mail_configuration and status != IGNORED_EXCEPTION

data/src/ruby_lib/exception_tracker/instrumentation/action_controller.rb

@@ -18,8 +18,10 @@
 
 module Webroar
   module ExceptionTracker
-    trace_rescue_action(:rescue_action, ActionController::Rescue, 'i') if ::Rails::VERSION::MAJOR < 3
-    trace_rescue_action(:rescue_with_handler, ActionController::Base, 'i') if ::Rails::VERSION::MAJOR > 2
+    if defined? ActionController
+      trace_rescue_action(:rescue_action, ActionController::Rescue, 'i') if ::Rails::VERSION::MAJOR < 3
+      trace_rescue_action(:rescue_with_handler, ActionController::Base, 'i') if ::Rails::VERSION::MAJOR > 2
+    end
   end # ExceptionTracker
 end # Webroar