errorhandling/logging-functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Logging Examples\n",
    "\n",
    "The following cells shows examples of how to use the various logging modules and functions. It also will display the outputs of each function.\n",
    "\n",
    "## Install Pre-Requisites and Load RAD Modules\n",
    "\n",
    "First we need to install the pre-requisites and load the RAD modules to be used in this notebook. The `Init.ps1` script will do this for us."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [],
   "source": [
    ". .\\samples\\Init.ps1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run `Get-Command` to list all the functions available in the RAD modules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\u001b[32;1mCommandType    \u001b[0m\u001b[32;1m Name                                              \u001b[0m\u001b[32;1m Version   \u001b[0m\u001b[32;1m Source\u001b[0m\n",
      "\u001b[32;1m-----------    \u001b[0m \u001b[32;1m----                                              \u001b[0m \u001b[32;1m-------   \u001b[0m \u001b[32;1m------\u001b[0m\n",
      "Function        Format-RadErrorMessage                             0.0        Rad-Error-Utils\n",
      "Function        Get-RadErrorMessage                                0.0        Rad-Error-Utils\n",
      "Function        Get-RadErrorMessages                               0.0        Rad-Error-Utils\n",
      "Function        Import-RadErrorsFromYaml                           0.0        Rad-Error-Utils\n",
      "Function        Invoke-TerminatingCommand                          0.0        Rad-Error-Utils\n",
      "Function        Set-RadErrorMessages                               0.0        Rad-Error-Utils\n",
      "Function        Confirm-LoggerIsEnabled                            0.0        Rad-Text-Utils\n",
      "Function        Show-DebugOutput                                   0.0        Rad-Text-Utils\n",
      "Function        Show-Error                                         0.0        Rad-Text-Utils\n",
      "Function        Show-FatalError                                    0.0        Rad-Text-Utils\n",
      "Function        Show-Output                                        0.0        Rad-Text-Utils\n",
      "Function        Show-Title                                         0.0        Rad-Text-Utils\n",
      "Function        Show-Warning                                       0.0        Rad-Text-Utils\n",
      "Function        Get-LogDirectory                                   0.0        Rad-Logging-Utils\n",
      "Function        Get-LoggingConfiguration                           0.0        Rad-Logging-Utils\n",
      "\n"
     ]
    }
   ],
   "source": [
    "Get-Command -Module Rad-Error-Utils\n",
    "Get-Command -Module Rad-Text-Utils\n",
    "Get-Command -Module Rad-Logging-Utils"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Enable PoshLog Logger\n",
    "\n",
    "Run the `Init-Logger.ps1` script to enable the PoshLog logger. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [],
   "source": [
    ". .\\samples\\Init-Logger.ps1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Rad-Error-Utils\n",
    "\n",
    "These are examples of how to use the `Rad-Error-Utils` module.\n",
    "\n",
    "### Get-RadErrorMessages\n",
    "\n",
    "`Get-RadErrorMessages` returns all the error codes and messages that are available:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\u001b[32;1mName                          \u001b[0m\u001b[32;1m Value\u001b[0m\n",
      "\u001b[32;1m----                          \u001b[0m \u001b[32;1m-----\u001b[0m\n",
      "101                            Error 101: Invalid parameter: {0}. Expected: {1}. Actual: {2}.\n",
      "500                            An unexpected error occurred while executing the command: [{0}]. Er…\n",
      "\n"
     ]
    }
   ],
   "source": [
    "Get-RadErrorMessages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get-RadErrorMessage\n",
    "\n",
    "`Get-RadErrorMessage` returns a specific error message based on the error code passed in. \n",
    "\n",
    "> Some messages allow parameters to be passed in to customize the message. More information on this can be found in the [Format-RadErrorMessage](#format-raderrormessage) section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error 101: Invalid parameter: param1. Expected: param2. Actual: param3.. Error Code: 101\n"
     ]
    }
   ],
   "source": [
    "Get-RadErrorMessage -ErrorCode 101 -Parameters \"param1\",\"param2\",\"param3\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- If a message requires parameters but they are not provided, the function will return an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[31;1mException: \u001b[31;1mError: The template requires 3 parameters, but only 0 were provided.\u001b[0m\n"
     ]
    },
    {
     "ename": "Error",
     "evalue": "Command failed: SubmitCode: Get-RadErrorMessage -ErrorCode 101 ",
     "output_type": "error",
     "traceback": [
      "Command failed: SubmitCode: Get-RadErrorMessage -ErrorCode 101 "
     ]
    }
   ],
   "source": [
    "Get-RadErrorMessage -ErrorCode 101 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- If the error code is not found, it will return a generic error message:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "An unexpected error occurred while executing the command. Error Code: 200\n"
     ]
    },
    {
     "ename": "Error",
     "evalue": "Command failed: SubmitCode: Get-RadErrorMessage -ErrorCode 200",
     "output_type": "error",
     "traceback": [
      "Command failed: SubmitCode: Get-RadErrorMessage -ErrorCode 200"
     ]
    }
   ],
   "source": [
    "Get-RadErrorMessage -ErrorCode 200"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Format-RadErrorMessage\n",
    "\n",
    "`Format-RadErrorMessage` is used to format error messages in a consistent way to improve readability and maintainability.\n",
    "\n",
    "It is also used to insert parameters into a message. It takes in a message and a list of parameters and returns the message with the parameters inserted. The parameters are inserted into the message in the order they are passed in in the list. Parameters are denoted in the message by `{}` and are required if they are present. Not all messages need to have parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "An unexpected error occurred while executing the command: [param1]. Error message: [param2]\n"
     ]
    }
   ],
   "source": [
    "$ErrorMessages = Get-RadErrorMessages\n",
    "$ErrorCode = \"500\"\n",
    "\n",
    "Format-RadErrorMessage -Template $ErrorMessages[$ErrorCode] -Parameters \"param1\",\"param2\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set-RadErrorMessages\n",
    "\n",
    "`Set-RadErrorMessages` allows you to add new error messages. It takes in a hashtable of error codes and messages and adds them to the existing error messages. If the error code already exists, it will overwrite the existing error message.\n",
    "\n",
    "For comparison purposes, these are the default error error messages available at the start:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\u001b[32;1mName                          \u001b[0m\u001b[32;1m Value\u001b[0m\n",
      "\u001b[32;1m----                          \u001b[0m \u001b[32;1m-----\u001b[0m\n",
      "101                            Error 101: Invalid parameter: {0}. Expected: {1}. Actual: {2}.\n",
      "500                            An unexpected error occurred while executing the command: [{0}]. Er…\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# For comparison purposes, these are the default error error messages available\n",
    "\n",
    "Get-RadErrorMessages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Now, let's add a few new error messages:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\u001b[32;1mName                          \u001b[0m\u001b[32;1m Value\u001b[0m\n",
      "\u001b[32;1m----                          \u001b[0m \u001b[32;1m-----\u001b[0m\n",
      "1000                           Unexpected error\n",
      "1001                           FileNotFoundError - Failure to locate or access a specified file or…\n",
      "1004                           PermissionDeniedError - Insufficient permissions to perform the {0}…\n",
      "1005                           TypeError - Mismatched data types or unsupported operations on a da…\n",
      "101                            Error 101: Invalid parameter: {0}. Expected: {1}. Actual: {2}.\n",
      "1010                           Unsupported operation - The operation {0} is not supported.\n",
      "500                            An unexpected error occurred while executing the command: [{0}]. Er…\n",
      "\n"
     ]
    }
   ],
   "source": [
    "$ErrorMessages = @{\n",
    "    \"1000\" = \"Unexpected error\"\n",
    "    \"1001\" = \"FileNotFoundError - Failure to locate or access a specified file or directory. [{0}]\"\n",
    "    \"1004\" = \"PermissionDeniedError - Insufficient permissions to perform the {0} operation.\"\n",
    "    \"1005\" = \"TypeError - Mismatched data types or unsupported operations on a data type {0}.\"\n",
    "    \"1010\" = \"Unsupported operation - The operation {0} is not supported.\"\n",
    "}\n",
    "\n",
    "Set-RadErrorMessages -NewErrorMessages $ErrorMessages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Next, let's update an existing error message. We should see the message for error code **1000** change from `Unexpected error` to `A RAD error message`:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\u001b[32;1mName                          \u001b[0m\u001b[32;1m Value\u001b[0m\n",
      "\u001b[32;1m----                          \u001b[0m \u001b[32;1m-----\u001b[0m\n",
      "1000                           A RAD error message\n",
      "1001                           FileNotFoundError - Failure to locate or access a specified file or…\n",
      "1004                           PermissionDeniedError - Insufficient permissions to perform the {0}…\n",
      "1005                           TypeError - Mismatched data types or unsupported operations on a da…\n",
      "101                            Error 101: Invalid parameter: {0}. Expected: {1}. Actual: {2}.\n",
      "1010                           Unsupported operation - The operation {0} is not supported.\n",
      "500                            An unexpected error occurred while executing the command: [{0}]. Er…\n",
      "\n"
     ]
    }
   ],
   "source": [
    "$ErrorMessages = @{\n",
    "    \"1000\" = \"A RAD error message\"\n",
    "}\n",
    "\n",
    "Set-RadErrorMessages -NewErrorMessages $ErrorMessages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. There is an *optional* parameter `-Overwrite` that will overwrite all the existing error messages with the new error messages. Let's try that now:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\u001b[32;1mName                          \u001b[0m\u001b[32;1m Value\u001b[0m\n",
      "\u001b[32;1m----                          \u001b[0m \u001b[32;1m-----\u001b[0m\n",
      "100                            FileNotFoundError - Failure to locate or access a specified file or…\n",
      "101                            PermissionDeniedError - Insufficient permissions to perform the {0}…\n",
      "102                            TypeError - Mismatched data types or unsupported operations on a da…\n",
      "103                            Unsupported operation - The operation {0} is not supported.\n",
      "403                            Authentication error - The user is not authenticated.\n",
      "500                            Unexpected error\n",
      "\n"
     ]
    }
   ],
   "source": [
    "$ErrorMessages = @{\n",
    "    \"500\" = \"Unexpected error\"\n",
    "    \"100\" = \"FileNotFoundError - Failure to locate or access a specified file or directory. [{0}]\"\n",
    "    \"101\" = \"PermissionDeniedError - Insufficient permissions to perform the {0} operation.\"\n",
    "    \"102\" = \"TypeError - Mismatched data types or unsupported operations on a data type {0}.\"\n",
    "    \"103\" = \"Unsupported operation - The operation {0} is not supported.\"\n",
    "    \"403\" = \"Authentication error - The user is not authenticated.\"\n",
    "}\n",
    "\n",
    "Set-RadErrorMessages -NewErrorMessages $ErrorMessages -Overwrite"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Now when you run Get-RadErrorMessages you will see the only new error messages:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\u001b[32;1mName                          \u001b[0m\u001b[32;1m Value\u001b[0m\n",
      "\u001b[32;1m----                          \u001b[0m \u001b[32;1m-----\u001b[0m\n",
      "100                            FileNotFoundError - Failure to locate or access a specified file or…\n",
      "403                            Authentication error - The user is not authenticated.\n",
      "101                            PermissionDeniedError - Insufficient permissions to perform the {0}…\n",
      "500                            Unexpected error\n",
      "103                            Unsupported operation - The operation {0} is not supported.\n",
      "102                            TypeError - Mismatched data types or unsupported operations on a da…\n",
      "\n"
     ]
    }
   ],
   "source": [
    "Get-RadErrorMessages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import-RadErrorsFromYaml\n",
    "\n",
    "`Import-RadErrorsFromYaml` is used to import error codes and messages from a YAML file. It takes in a path to a YAML file and returns a hashtable of the error codes and messages. This allows you to add your own custom error codes and messages. The YAML file must be in the following format:\n",
    "\n",
    "```yaml\n",
    "  # common_errors.yaml\n",
    "  errors:\n",
    "    500: \"Unexpected error\"\n",
    "    100: \"FileNotFoundError - Failure to locate or access a specified file or directory. [{0}]\"\n",
    "    101: \"PermissionDeniedError - Insufficient permissions to perform the {0} operation.\"\n",
    "    102: \"TypeError - Mismatched data types or unsupported operations on a data type {0}.\"\n",
    "    103: \"Unsupported operation - The operation {0} is not supported.\"\n",
    "    403: \"Authentication error - The user is not authenticated.\"\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\u001b[32;1mName                          \u001b[0m\u001b[32;1m Value\u001b[0m\n",
      "\u001b[32;1m----                          \u001b[0m \u001b[32;1m-----\u001b[0m\n",
      "104                            Docker is not running. Please start Docker and run the script again.\n",
      "103                            Unsupported operation - The operation {0} is not supported.\n",
      "500                            Unexpected error\n",
      "101                            PermissionDeniedError - Insufficient permissions to perform the {0}…\n",
      "102                            TypeError - Mismatched data types or unsupported operations on a da…\n",
      "403                            Authentication error - The user is not authenticated.\n",
      "100                            FileNotFoundError - Failure to locate or access a specified file or…\n",
      "\n"
     ]
    }
   ],
   "source": [
    "Import-RadErrorsFromYaml -YamlFile \".\\samples\\errors-example.yaml\"\n",
    "\n",
    "Get-RadErrorMessages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Invoke-TerminatingCommand\n",
    "\n",
    "`Invoke-TerminatingCommand` is used to execute a command and handle any terminating errors that may occur. It takes in a command, an error code and, if necessary, a hashtable of parameters to pass to the command. It will invoke the command and if a terminating error occurs, it will handle the error and return error message, error code and error details using [Show-FatalError](#show-fatalerror). If no terminating error occurs, it will return the output of the command."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[19:19:05 INF] Executing Command: [ az account show ]\n",
      "\u001b[31;1mERROR: Please run 'az login' to setup account.\u001b[0m\n",
      "[19:19:06 FTL] Authentication error - The user is not authenticated.. Error Code: 403\n",
      "\u001b[31;1mException: \u001b[31;1mAuthentication error - The user is not authenticated.. Error Code: 403\u001b[0m\n"
     ]
    },
    {
     "ename": "Error",
     "evalue": "Command failed: SubmitCode: Invoke-TerminatingCommand -Command { az account sh ...",
     "output_type": "error",
     "traceback": [
      "Command failed: SubmitCode: Invoke-TerminatingCommand -Command { az account sh ..."
     ]
    }
   ],
   "source": [
    "Invoke-TerminatingCommand -Command { az account show } -ErrorCode 403"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[19:19:20 INF] Executing Command: [ dotnet --version ]\n",
      "[19:19:20 INF] Command executed successfully.\n",
      "8.0.100\n"
     ]
    }
   ],
   "source": [
    "Invoke-TerminatingCommand -Command { dotnet --version } -ErrorCode 500"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Rad-Text-Utils\n",
    "\n",
    "These are examples of how to use the `Rad-Text-Utils` module. When the logger is enabled, these functions will write to a new directory called [~/.utils-logs](~/.utils-logs) and create a new log file `utils-<yyyymmdd>.log`. The logs will write to the console as well as the log file. See below for an example of what a log file will look like:\n",
    "\n",
    "```text\n",
    "    04:48:05 [INF] {\"ScriptName\":\"utils\"} # THIS IS A TITLE \n",
    "    04:48:10 [INF] {\"ScriptName\":\"utils\"} This is an example output \n",
    "    04:48:13 [DBG] {\"ScriptName\":\"utils\"} This is an example debug output \n",
    "    04:48:17 [WRN] {\"ScriptName\":\"utils\"} This is an example warning \n",
    "    04:48:21 [ERR] {\"ScriptName\":\"utils\"} This is an example non-terminating error \n",
    "    04:48:24 [FTL] {\"ScriptName\":\"utils\"} This is an example terminating error \n",
    "```\n",
    "\n",
    "> If a logger is not enabled, the functions will default to use `Write-Host`, `Write-Debug`, or `Write-Warning` accordingly to display in the console.\n",
    "\n",
    "### Confirm-LoggerIsEnabled\n",
    "\n",
    "`Confirm-LoggerIsEnabled` is used to confirm that the logger is enabled. It takes in a logger object and returns a boolean value indicating if the logger is enabled or not.\n",
    "\n",
    "We enabled the logger at the start of this notebook, so this function should return `True`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "Confirm-LoggerIsEnabled"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Show-Title\n",
    "\n",
    "`Show-Title` is used to display a title in the console. It takes in a string and displays it in the console starting with a `#` and capitalizing the text. \n",
    "\n",
    "> If you have a logger enabled, the function will use `Write-InfoLog` to display and log the title. Informational logs are displayed in the console with a `[INF]` in front of it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[19:21:15 INF] # GETTING AZURE RESOURCES WITHOUT TAG\n"
     ]
    }
   ],
   "source": [
    "Show-Title \"Getting Azure Resources Without Tag\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Show-Output\n",
    "\n",
    "`Show-Output` is used to display informational messages to the console. \n",
    "\n",
    "> If you have a logger enabled, the function will use `Write-InfoLog` to diplay and log the output. Informational logs are displayed in the console with a `[INF]` in front of it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[19:21:22 INF] Connecting to Azure\n"
     ]
    }
   ],
   "source": [
    "Show-Output \"Connecting to Azure\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Show-DebugOutput\n",
    "\n",
    "`Show-DebugOutput` is used to display debug messages in the console.\n",
    "\n",
    "> If you have a logger enabled, the function will use `Write-DebugLog` to log the debug messages. Debug logs are displayed in the log file with a `[DBG]` in front of it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [],
   "source": [
    "Show-DebugOutput \"This is an example debug output\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Warnings and Errors\n",
    "\n",
    "You will use the [Get-RadErrorMessage](#get-raderrormessage) function to get the error messages. The error messages are stored in a hashtable and are accessed by the error code. This message is then passed into the appropriate `Show` function to display the message in the console and log it if a logger is enabled.\n",
    "\n",
    "## Show-Warning\n",
    "\n",
    "`Show-Warning` is used to display a warning in the console. It takes in a text string and displays it in the console with a `WARNING:` in front of it. Warnings will not terminate your script and will continue to run.\n",
    "\n",
    "> If you have a logger enabled, the function will use `Write-WarningLog` to display and log the warning. Warning logs are displayed in the console with a `[WRN]` in front of it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING: FileNotFoundError - Failure to locate or access a specified file or directory. [file-does-not-exist.ps1]. Error Code: 100\n",
      "[19:22:59 WRN] FileNotFoundError - Failure to locate or access a specified file or directory. [file-does-not-exist.ps1]. Error Code: 100\n"
     ]
    }
   ],
   "source": [
    "Show-Warning (Get-RadErrorMessage -ErrorCode 100 -Parameters \"file-does-not-exist.ps1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Show-Error\n",
    "\n",
    "`Show-Error` is used to display non-terminating errors in the console. It takes in a text string and displays it in the console with a `ERROR:` in front of it.\n",
    "\n",
    "> If you have a logger enabled, the function will use `Write-ErrorLog` to display and log the error. Error logs are displayed in the console with a `[ERR]` in front of it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[31;1mShow-Error: \u001b[31;1mPermissionDeniedError - Insufficient permissions to perform the Get-AzResource operation.. Error Code: 101\u001b[0m\n",
      "[19:23:03 ERR] PermissionDeniedError - Insufficient permissions to perform the Get-AzResource operation.. Error Code: 101\n"
     ]
    },
    {
     "ename": "Error",
     "evalue": "Command failed: SubmitCode: Show-Error (Get-RadErrorMessage -ErrorCode 101 -Pa ...",
     "output_type": "error",
     "traceback": [
      "Command failed: SubmitCode: Show-Error (Get-RadErrorMessage -ErrorCode 101 -Pa ..."
     ]
    }
   ],
   "source": [
    "Show-Error (Get-RadErrorMessage -ErrorCode 101 -Parameters \"Get-AzResource\",\"param1\",\"param2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Show-FatalError\n",
    "\n",
    "`Show-FatalError` is used to display a fatal error in the console and terminates the script that is being run. It takes in a text string and displays it in the console with a `FATAL ERROR:` or `Exception` in front of it.\n",
    "\n",
    "The [Invoke-TerminatingCommand](#invoke-terminatingcommand) function utilizes this function when running a command that may return a terminating error.\n",
    "\n",
    "> If you have a logger enabled, the function will use `Write-FatalLog` to display and log the fatal error. Fatal logs are displayed in the console with a `[FTL]` in front of it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[19:23:11 FTL] Docker is not running. Please start Docker and run the script again.. Error Code: 104\n",
      "\u001b[31;1mException: \u001b[31;1mDocker is not running. Please start Docker and run the script again.. Error Code: 104\u001b[0m\n"
     ]
    },
    {
     "ename": "Error",
     "evalue": "Command failed: SubmitCode: Show-FatalError (Get-RadErrorMessage -ErrorCode '1 ...",
     "output_type": "error",
     "traceback": [
      "Command failed: SubmitCode: Show-FatalError (Get-RadErrorMessage -ErrorCode '1 ..."
     ]
    }
   ],
   "source": [
    "Show-FatalError (Get-RadErrorMessage -ErrorCode '104')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Next Steps\n",
    "\n",
    "Now let's run a script that utilizes these functions. This script will import the RAD modules, enable the logger, and then run the various functions in this notebook. We will then look at the log file to see what was logged.\n",
    "\n",
    "Make sure that you are running the following cells out of the `samples` directory:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [],
   "source": [
    "cd /workspaces/rad-powershell-cmdlets/errorhandling/samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[23:58:15 INF] # GETTING AZURE RESOURCES WITHOUT TAG\n",
      "[23:58:15 INF] Connecting to Azure\n",
      "[23:58:15 INF] Executing Command: [ Connect-AzAccount ]\n",
      "\u001b[93mWARNING: Interactive authentication is not supported in this session, please run cmdlet 'Connect-AzAccount -UseDeviceAuthentication'.\u001b[0m\n",
      "[23:58:17 FTL] An unexpected error occurred while executing the command. Error Code: 403\n",
      "\u001b[31;1mException: \u001b[31;1mAn unexpected error occurred while executing the command. Error Code: 403\u001b[0m\n"
     ]
    },
    {
     "ename": "Error",
     "evalue": "Command failed: SubmitCode: ./Show-AzResourcesWithoutTag.ps1",
     "output_type": "error",
     "traceback": [
      "Command failed: SubmitCode: ./Show-AzResourcesWithoutTag.ps1"
     ]
    }
   ],
   "source": [
    "./Show-AzResourcesWithoutTag.ps1"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".NET (C#)",
   "language": "C#",
   "name": ".net-csharp"
  },
  "language_info": {
   "name": "polyglot-notebook"
  },
  "polyglot_notebook": {
   "kernelInfo": {
    "defaultKernelName": "csharp",
    "items": [
     {
      "aliases": [],
      "name": "csharp"
     }
    ]
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}