monitoreo_de_errores.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Monitoreo (logging) de errores \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objetivos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Obtener un feedback mucho más completo sobre lo que produjo el error que se está presentando\n",
    "* Conocer las herramientas más utilizadas para loggeo de erroes en Python\n",
    "* Obtener el conocimiento necesario para crear sus propias excepciones (Custom Error Exceptions)\n",
    "* Ser capaz de ejecutar un script en background y monitorear el estado del mismo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ## Introducción "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las herramientas de monitoreo capturan, analizan y muestran información para la ejecución de una aplicación o script. Cada aplicación tiene problemas que surgen en las distintas capas de la misma. Las herramientas de monitoreo brindan transparencia para que los desarrolladores y los equipos de operaciones puedan encontrar, entender y solucionar estos problemas.\n",
    "\n",
    "### ¿Por qué es necesario el monitoreo?\n",
    "Capturar y analizar datos sobre su entorno de producción es fundamental para lidiar proactivamente con la estabilidad, el rendimiento y los errores en una aplicación. Si no contamos con estos datos el proceso de encontrar la solución es mucho más largo y tedioso.\n",
    "\n",
    "### Diferencia entre monitoreo y logging\n",
    "El monitoreo y el logging son muy similares en su propósito de ayudar a diagnosticar problemas con una aplicación y ayudar al proceso de depuración. Una forma de pensar en la diferencia es que el logging se realiza en función de eventos explícitos, mientras que el monitoreo es una recopilación pasiva de datos en segundo plano.\n",
    "\n",
    "Por ejemplo, cuando ocurre un error, ese evento se registra explícitamente a través del código en un controlador de excepciones. Mientras tanto, una herramienta de monitoreo instrumenta el código y recopila datos no solo sobre la excepción registrada sino también sobre el rendimiento de las funciones.\n",
    "\n",
    "Esta distinción entre logging y monitoreo es vaga y no necesariamente es la única forma de verlo. Pragmáticamente, ambos son útiles para poder solucionar los errores que pudiesen existir.\n",
    "\n",
    "Pero para poder entender sobre monitoreo, primero debemos entender sobre los avisos y la información que tendremos disponible para monitorear y esa información sobre el error es llamada \"excepción\"\n",
    "\n",
    "## Monitoreo\n",
    "\n",
    "### Monitoreo en las distintas capas\n",
    "Hay varios recursos importantes para monitorear en el sistema operativo y el nivel de red.\n",
    "\n",
    "* Utilización de la CPU\n",
    "* Utilización de la memoria\n",
    "* Almacenamiento de datos y espacio libre\n",
    "* Ancho de banda de red y latencia\n",
    "\n",
    "El monitoreo de nivel de aplicación abarca varios aspectos. La cantidad de tiempo y recursos dedicados a cada aspecto variarán en función de si una aplicación es pesada para lectura, escritura o está sujeta a cambios rápidos en el tráfico, estas son algunos de los parametros que comunmente se miden:\n",
    "\n",
    "* Advertencias y errores de la aplicación (errores HTTP de 500 niveles)\n",
    "* Rendimiento del código de la aplicación\n",
    "* Tiempo de renderizado (visual)\n",
    "* Tiempo de representación del navegador para la aplicación\n",
    "* Rendimiento de consultas de bases de datos\n",
    "\n",
    "### Excepciones en Python\n",
    "Una excepción es básicamente la alerta o \"call\" que va a lanzar un script cuando un error sucedió en tiempo de ejecución. En python existen principalmente dos tipos de excepciones que a su vez se dividen en un amplia gama de errores. El primer tipo son las \"Syntax Error\" o error de sintaxis que se refieren a un error de sintaxis específica del lenguaje de programación, el segundo tipo son las Excepciones en general que se subdividen dependiendo del origen del error.\n",
    "Estas Excepciones en ejecución no son incondicionalmente fatales sin embargo, la mayoría de las excepciones no son manejadas por los programas y dan como resultado mensajes de error por ejemplo:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-2-0b280f36835c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;36m10\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "10 * (1/0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como podemos ver, es imposible realizar una division dentro de cero con python, ya que esto siempre lanzará un error.\n",
    "\n",
    "Sin embargo la información que nos da python sobre el error puede que no sea suficiente por si sola para detectar donde ocurrió o el porque.\n",
    "Es allí donde necesitamos las herramientas de logging para poder tener un feedback más amplio sobre lo que está sucediendo.\n",
    "\n",
    "Por otro lado, también es posible hacer un \"catch\" del error para que no falle de manera fatal y detenga el script sino más bien unicamente nos avise que algo salio mal pero que no es critico, si así lo definimos. \n",
    "Por ejemplo en este caso:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No se puede realizar una division por cero\n",
      "Pero el script se sigue ejecutando\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    10 * (1/0)\n",
    "except Exception as e:\n",
    "    print(\"No se puede realizar una division por cero\")\n",
    "\n",
    "print(\"Pero el script se sigue ejecutando\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A demás de las excepciones que ya están definidas por default, tenemos la opción de construir nuestras propias excepciones, estas son especialmente utiles cuando no ocurre un error como tal pero para nuestro proceso si es un error grave, por ejemplo cuando recibimos una cadena de información que tiene una forma incorrecta, como podemos ver en el siguiente script:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "InadequateFormatException",
     "evalue": "El formato de la variable es incorrecto",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mInadequateFormatException\u001b[0m                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-2-085a55edb241>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     16\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"La variable si es correcta\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 18\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mInadequateFormatException\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     19\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     20\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mInadequateFormatException\u001b[0m: El formato de la variable es incorrecto"
     ]
    }
   ],
   "source": [
    "# definimos una clase que va a derivar de la clase base de excepciones\n",
    "class InadequateFormatException(Exception):\n",
    "    def __init__(self,*args,**kwargs): # inicializamos la clase con los argumentos que recibimos por default\n",
    "        Exception.__init__(self, \"El formato de la variable es incorrecto\") # agregamos un mensaje customizado\n",
    "     \n",
    "    \n",
    "variable_incorrecta = \"1\"\n",
    "\n",
    "def check_var_format(variable):\n",
    "    if isinstance(variable, int):\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "        \n",
    "if check_var_format(variable_incorrecta):\n",
    "    print(\"La variable si es correcta\")\n",
    "else:\n",
    "    raise InadequateFormatException()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como podemos ver, aunque no sucedió ningún error fatal, el script lanzó una excepción alertando que el formato de la variable es incorrecta, podemos notar también que a demás de ello, nos indica donde ocurrió el error, esto es debido a que deribamos las funcionalidades de una excepción por default."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logging"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El logging es un medio para rastrear eventos que suceden cuando se ejecuta una aplicación o script. El desarrollador del software agrega llamadas de logging a su código para indicar que se han producido ciertos eventos. Un evento se describe mediante un mensaje descriptivo que opcionalmente puede contener datos de variables (es decir, datos que son potencialmente diferentes para cada ocurrencia del evento). Los eventos también tienen una importancia que el desarrollador atribuye al evento; La importancia también se puede llamar el nivel o la gravedad.\n",
    "\n",
    "El registro proporciona un conjunto de funciones convenientes para un uso de registro simple. Estos son debug(), info(), warning(), error()y critical(). \n",
    "\n",
    "\n",
    "**DEBUG**  \n",
    "Información detallada, típicamente de interés solo al diagnosticar problemas.\n",
    "\n",
    "**INFO**  \n",
    "Confirmación de que las cosas funcionan como se esperaba.\n",
    "\n",
    "**WARNING**  \n",
    "Una indicación de que sucedió algo inesperado, o indicativo de algún problema en el futuro cercano (por ejemplo, 'espacio en disco bajo'). El software todavía funciona como se esperaba.\n",
    "\n",
    "**ERROR**  \n",
    "Debido a un problema más grave, el software no ha podido realizar alguna función.\n",
    "\n",
    "**CRITICAL**  \n",
    "Un error grave, que indica que el programa en sí mismo puede no poder continuar ejecutándose.\n",
    "\n",
    "Una de las bibliotecas más utilizadas para logging es \"Logging\"\n",
    "para utilizarla debemos importarla y hacer uso de sus distintos niveles de mensaje como vemos a continuación:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:root:Cuidado! esta es una advertencia!\n"
     ]
    }
   ],
   "source": [
    "import logging\n",
    "\n",
    "logging.warning('Cuidado! esta es una advertencia!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "ERROR:root:Este es un mensaje de error, usualmente se utiliza dentro de las excepciones\n"
     ]
    }
   ],
   "source": [
    "logging.error('Este es un mensaje de error, usualmente se utiliza dentro de las excepciones') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Monitoreo en Background"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "el loggeo de eventos es muy sencillo cuando podemos ver los mensajes en tiempo real en la linea de comandos, pero que sucede cuando el script se está ejecutando en background? cómo podemos ver las advertencias y los mensajes de información que lanzó el script?\n",
    "Una opción es usar la condición PYTHONUNBUFFERED, que nos permitirá especificar un archivo donde podremos guardar los logs y todas las alertas que se deberían de mostrar en pantalla en tiempo de ejecución como podemos ver en el siguiente ejemplo:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "python -u 1.py > 1.output & \n",
    "\n",
    "el -u indica que la variable PYTHONBUFFERED está activada \n",
    "y el & indica que el script debe ejecutarse en background"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y la opción más recomendada es utilizar la configuración del Logger para guardar toda la información en un archivo específico:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# configuramos donde se guardará y cual será el método de escritura\n",
    "logging.basicConfig(\n",
    "    level=logging.DEBUG,\n",
    "    filename='miscript.log',\n",
    "    filemode='w'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para poder estar seguros de que el script si se está ejecutando correctamente debemos ejecutar el siguiente comando   \n",
    "`ps axuw | grep python_background`  \n",
    "donde python_background es el nombre de nuestro archivo con el script"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTA**\n",
    "Para este ejemplo debemos ejecutarlo desde la consola por lo que debemos dirigirnos al recurso con nombre python_background.py  \n",
    "para que se ejecute en background debemos poner un `&` despues del comando de ejecución osea:  \n",
    "`python3 python_background.py &`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ejercicios:\n",
    "1. Utilizando https://mailtrap.io/, crea una cuenta falsa de emails y utiliza las credenciales que se generaron para crear un script que te envíe un email cada minuto con un texto cualquiera (simulando un error que ejecuta una acción en un sistema). Toma en cuenta que el script debe ejecutarse en background y debe guardar un log cada vez que el email se envía.  \n",
    "    Tip: para enviar un email podemos utilizar el siguiente código, adaptalo a tu código.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import smtplib\n",
    "\n",
    "sender = \"Private Person <from@smtp.mailtrap.io>\"\n",
    "receiver = \"A Test User <to@smtp.mailtrap.io>\"\n",
    "\n",
    "message = f\"\"\"\\\n",
    "Subject: Hi Mailtrap\n",
    "To: {receiver}\n",
    "From: {sender}\n",
    "\n",
    "This is a test e-mail message.\"\"\"\n",
    "\n",
    "with smtplib.SMTP(\"smtp.mailtrap.io\", 2525) as server:\n",
    "    server.login(\"<USERNAME>\", \"<PASSWORD>\")\n",
    "    server.sendmail(sender, receiver, message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Highligts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bibliografía"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://docs.python.org/3/tutorial/errors.html Errors and Exceptions 2019"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://docs.python.org/3/howto/logging.html logging howto 2019"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://docs.python.org/3/using/cmdline.html Command line and environment¶ 2019\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}