@suffolklitlab/alkiln 5.12.0 → 5.13.0-logs2

package/action.yml

@@ -1,5 +1,5 @@
 name: "ALKiln: Automated docassemble tests"
-description: "Automatically test any docassemble interview in a any branch on your GitHub repository whenever you commit or push. See https://suffolklitlab.org/docassemble-AssemblyLine-documentation/docs/automated_integrated_testing."
+description: "Automatically test any docassemble interview in a any branch on your GitHub repository whenever you commit or push. See https://suffolklitlab.org/docassemble-AssemblyLine-documentation/docs/alkiln/setup/#types."
 
 inputs:
   SERVER_URL:
@@ -41,6 +41,9 @@ outputs:
   PATH_TO_REPORT_FILE:
     description: 'An empty string ("") or the path to report.txt. Remember to check for the existence of the file before using it.'
     value: ${{ steps.alkiln_outputs.outputs.PATH_TO_REPORT_FILE }}
+  PATH_TO_REPORT_LOG_FILE:
+    description: 'An empty string ("") or the path to report_log.txt. Remember to check for the existence of the file before using it.'
+    value: ${{ steps.alkiln_outputs.outputs.PATH_TO_REPORT_LOG_FILE }}
   PATH_TO_UNEXPECTED_RESULTS_FILE:
     description: 'An empty string ("") or the path to unexpected_results.txt. Remember to check for the existence of the file before using it.'
     value: ${{ steps.alkiln_outputs.outputs.PATH_TO_UNEXPECTED_RESULTS_FILE }}
@@ -67,9 +70,18 @@ runs:
         DOCASSEMBLECLI_VERSION: ${{ inputs.DOCASSEMBLECLI_VERSION }}
       shell: bash
       run: |
-        # 💡 ALK0023 INFO: Set environment variables
+        log="💡 ALK0023 INFO: Set environment variables"
+
         # Human-readable date/time: https://www.shell-tips.com/linux/how-to-format-date-and-time-in-linux-macos-and-bash/#how-to-format-a-date-in-bash
-        echo "ARTIFACT_NAME=alkiln-$(date +'%Y-%m-%d at %Hh%Mm%Ss' -u)UTC" >> $GITHUB_ENV
+        timestamp="$(date +'%Y-%m-%d at %Hh%Mm%Ss' -u)"
+        artifact_folder="alkiln-${timestamp}UTC"
+        echo "ARTIFACT_FOLDER=$artifact_folder" >> $GITHUB_ENV
+        debug_path="${artifact_folder}/debug_log.txt"
+        echo "DEBUG_PATH=$debug_path" >> $GITHUB_ENV
+
+        mkdir -p "$artifact_path"
+        echo "$log" >> "$debug_path"
+
         echo "REPO_URL=${{ github.server_url }}/${{ github.repository }}" >> $GITHUB_ENV
         echo "BRANCH_PATH=$BRANCH_PATH" >> $GITHUB_ENV
         # Workflow inputs
@@ -84,18 +96,21 @@ runs:
     - name: "💡 ALK0024 INFO: Confirm environment variables"
       shell: bash
       run: |
-        # 💡 ALK0024 INFO: Confirm environment variables
-        echo -e "\nALKiln version is $ALKILN_VERSION\nRepo is $REPO_URL\nBranch ref is $BRANCH_PATH\nMAX_SECONDS_FOR_SETUP is $MAX_SECONDS_FOR_SETUP\nSERVER_RELOAD_TIMEOUT_SECONDS is $SERVER_RELOAD_TIMEOUT_SECONDS\n"
+        log="💡 ALK0024 INFO: Confirm environment variables"
+        echo -e "\n$log" >> "$DEBUG_PATH"
+        vars_log="\nALKiln version is $ALKILN_VERSION\nRepo is $REPO_URL\nBranch ref is $BRANCH_PATH\nMAX_SECONDS_FOR_SETUP is $MAX_SECONDS_FOR_SETUP\nSERVER_RELOAD_TIMEOUT_SECONDS is $SERVER_RELOAD_TIMEOUT_SECONDS\n"
+        echo -e "$vars_log" >> "$DEBUG_PATH" && echo -e "$vars_log"
 
     # Install
-    - name: "💡 ALK0025 INFO: Install node packages"
+    - name: "💡 ALK0025 INFO: Set up node"
       uses: actions/setup-node@v4
       with:
         node-version: "18"
     - name: "💡 ALK0026 INFO: Install ALKiln directly from npm"
       shell: bash
       run: |
-        # 💡 ALK0026 INFO: Install ALKiln directly from npm
+        log="💡 ALK0026 INFO: Install ALKiln directly from npm"
+        echo -e "\n$log" >> "$DEBUG_PATH"
         npm install -g "@suffolklitlab/alkiln@$ALKILN_VERSION"
 
     # Install on playground
@@ -109,26 +124,32 @@ runs:
       if: ${{ inputs.INSTALL_METHOD == 'playground' }}
       shell: bash
       run: |
-        # 💡 ALK0027 INFO: Create a Project and install the package from GitHub
+        log="💡 ALK0027 INFO: Create a Project and install the package from GitHub"
+        echo -e "\n$log" >> "$DEBUG_PATH"
         pip install "docassemblecli==$DOCASSEMBLECLI_VERSION"
-        alkiln-setup
-    - name: "😞 ALK0028 ERROR: Unable to create a Project"
+        alkiln-setup --path="$ARTIFACT_FOLDER"
+    - name: "🤕 ALK0028 ERROR: Unable to create a Project"
       if: ${{ inputs.INSTALL_METHOD == 'playground' && failure() }}
       shell: bash
       run: |
-        # 😞 ALK0028 ERROR: Unable to create a Project
-        echo -e "\n\n====\n😞 ALK0028 ERROR: Unable to create a Project on your server's testing account or pull your package into it. Check the messages above this line.\n\n"
+        # "🤕 ALK0028 ERROR: Unable to create a Project"
+        long_log="\n\n―――\n🤕 ALK0028 ERROR: Unable to create a Project on your server's testing account or pull your package into it. Check the messages above this line.\n\n"
+        echo -e "$long_log" >> "$DEBUG_PATH" && echo -e "$long_log"
 
     # Server installations - find folders and save session vars
     - name: "💡 ALK0029 INFO: Install the GitHub package onto the server"
       if: ${{ inputs.INSTALL_METHOD == 'server' }}
       shell: bash
-      run: alkiln-server-install
-    - name: "😞 ALK0030 ERROR: Unable to install the package"
+      run: |
+        log="💡 ALK0029 INFO: Install the GitHub package onto the server"
+        echo -e "\n$log" >> "$DEBUG_PATH"
+        alkiln-server-install --path="$ARTIFACT_FOLDER"
+    - name: "🤕 ALK0030 ERROR: Unable to install the package"
       if: ${{ inputs.INSTALL_METHOD == 'server' && failure() }}
       shell: bash
       run: |
-        echo -e "\n\n====\n😞 ALK0030 ERROR: Unable to install the package on the temporary GitHub docassemble server. Check the steps above this line.\n\n"
+        log="\n\n―――\n🤕 ALK0030 ERROR: Unable to install the package on the temporary GitHub docassemble server. Check the steps above this line.\n\n"
+        echo -e "$log" >> "$DEBUG_PATH" && echo -e "$log"
 
     # run tests
     - name: "💡 ALK0031 INFO: Run tests"
@@ -136,20 +157,26 @@ runs:
       env:
         ALKILN_TAG_EXPRESSION: ${{ inputs.ALKILN_TAG_EXPRESSION || github.event.inputs.tags && format('{0}', github.event.inputs.tags) }}
       shell: bash
-      run: alkiln-run "$ALKILN_TAG_EXPRESSION"
+      run: |
+        log="💡 ALK0031 INFO: Run tests"
+        echo -e "\n$log" >> "$DEBUG_PATH"
+        alkiln-run "$ALKILN_TAG_EXPRESSION" --path="$ARTIFACT_FOLDER"
     
     # on playground, delete project
     - name: "💡 ALK0032 INFO: Delete the Project from the Playground"
       if: ${{ always() && inputs.INSTALL_METHOD == 'playground' }}
-      run: alkiln-takedown
       shell: bash
+      run: |
+        log="💡 ALK0032 INFO: Delete the Project from the Playground"
+        echo -e "\n$log" >> "$DEBUG_PATH"
+        alkiln-takedown --path="$ARTIFACT_FOLDER"
     
     # Upload artifacts that subscribers can download on the Actions summary page
     - name: "💡 ALK0033 INFO: Upload artifacts folder"
       if: ${{ always() }}
       uses: actions/upload-artifact@v4
       with:
-        name: ${{ env.ARTIFACT_NAME }}
+        name: ${{ env.ARTIFACT_FOLDER }}
         path: ./alkiln-*
 
     # Download artifacts folder internally to create action output
@@ -157,45 +184,56 @@ runs:
       if: ${{ always() }}
       uses: actions/download-artifact@v4
       with:
-        name: ${{ env.ARTIFACT_NAME }}
+        name: ${{ env.ARTIFACT_FOLDER }}
 
     - name: "💡 ALK0184 INFO: Prepare ALKiln output file paths"
       if: ${{ always() }}
       id: alkiln_outputs
       shell: bash
       run: |
-        # 💡 ALK0184 INFO: Prepare ALKiln output file paths
+        log="💡 ALK0184 INFO: Prepare ALKiln output file paths"
+        echo -e "\n$log" >> "$DEBUG_PATH" && echo "$log"
 
         FOLDER=$(ls -d */ | grep -E '^alkiln-*' || true)
 
-        echo "Test results artifacts folder is $FOLDER"
+        log_folder="Test results artifacts folder is $FOLDER"
+        echo -e "\n$log_folder" >> "$DEBUG_PATH" && echo "$log_folder"
 
         if [[ "$FOLDER" = "" ]]; then
-          echo "Artifacts folder is missing. The path is an empty string: '$FOLDER'"
+          log_missing="Artifacts folder is missing. The path is an empty string: '$FOLDER'"
+          echo -e "\n$log_missing" >> "$DEBUG_PATH" && echo "$log_missing"
 
         else
           REPORT_PATH="${FOLDER}report.txt"
+          REPORT_LOG_PATH="${FOLDER}report_log.txt"
           UNEXPECTED_RESULTS_PATH="${FOLDER}unexpected_results.txt"
           DEBUG_LOG_PATH="${FOLDER}debug_log.txt"
 
           if [ -f "$REPORT_PATH" ]; then
-            echo "$REPORT_PATH exists"
+            echo -e "\n$REPORT_PATH exists" >> "$DEBUG_PATH" && echo "$REPORT_PATH exists"
           else
-            echo "$REPORT_PATH is missing"
+            echo -e "\n$REPORT_PATH is missing" >> "$DEBUG_PATH" && echo "$REPORT_PATH is missing"
             REPORT_PATH=""
           fi
 
+          if [ -f "$REPORT_LOG_PATH" ]; then
+            echo -e "\n$REPORT_LOG_PATH exists" >> "$DEBUG_PATH" && echo "$REPORT_LOG_PATH exists"
+          else
+            echo -e "\n$REPORT_LOG_PATH is missing" >> "$DEBUG_PATH" && echo "$REPORT_LOG_PATH is missing"
+            REPORT_LOG_PATH=""
+          fi
+
           if [ -f "$UNEXPECTED_RESULTS_PATH" ]; then
-            echo "$UNEXPECTED_RESULTS_PATH exists"
+            echo -e "\n$UNEXPECTED_RESULTS_PATH exists" >> "$DEBUG_PATH" && echo "$UNEXPECTED_RESULTS_PATH exists"
           else
-            echo "$UNEXPECTED_RESULTS_PATH is missing"
+            echo -e "\n$UNEXPECTED_RESULTS_PATH is missing" >> "$DEBUG_PATH" && echo "$UNEXPECTED_RESULTS_PATH is missing"
             UNEXPECTED_RESULTS_PATH=""
           fi
 
           if [ -f "$DEBUG_LOG_PATH" ]; then
-            echo "$DEBUG_LOG_PATH exists"
+            echo -e "\n$DEBUG_LOG_PATH exists" >> "$DEBUG_PATH" && echo "$DEBUG_LOG_PATH exists"
           else
-            echo "$DEBUG_LOG_PATH is missing"
+            echo -e "\n$DEBUG_LOG_PATH is missing" >> "$DEBUG_PATH" && echo "$DEBUG_LOG_PATH is missing"
             DEBUG_LOG_PATH=""
           fi
 
@@ -203,6 +241,7 @@ runs:
 
         echo "PATH_TO_ARTIFACTS=$FOLDER" >> "$GITHUB_OUTPUT"
         echo "PATH_TO_REPORT_FILE=$REPORT_PATH" >> "$GITHUB_OUTPUT"
+        echo "PATH_TO_REPORT_LOG_FILE=$REPORT_LOG_PATH" >> "$GITHUB_OUTPUT"
         echo "PATH_TO_UNEXPECTED_RESULTS_FILE=$UNEXPECTED_RESULTS_PATH" >> "$GITHUB_OUTPUT"
         echo "PATH_TO_DEBUG_LOG_FILE=$DEBUG_LOG_PATH" >> "$GITHUB_OUTPUT"
 
@@ -212,4 +251,5 @@ runs:
     - shell: bash
       if: ${{ always() }}
       run: |
-        echo "💡 ALK0034 INFO: ALkiln finished running tests"
+        log="💡 ALK0034 INFO: ALkiln finished running tests. See above for more details."
+        echo -e "\n$log" >> "$DEBUG_PATH" && echo "$log"

package/action_for_github_server/action.yml

@@ -47,12 +47,31 @@ runs:
       # Place the root directory in this branch
       - uses: actions/checkout@v4
 
+      - shell: bash
+        if: ${{ always() && env.OUTPUT_DOCKER == 'true' }}
+        name: "💡 ALK0018 INFO: Create artifact paths with date and time"
+        run: |
+          log="💡 ALK0018 INFO: Get path names with date and time"
+          timestamp="$(date +'%Y-%m-%d at %Hh%Mm%Ss' -u)"
+          debug_dir="/tmp"
+          debug_path="$debug_dir/alkiln_docker_logs-${timestamp}UTC.txt"
+          artifact_path="alkiln_github_server-${timestamp}UTC"
+
+          mkdir -p "$debug_dir"
+          mkdir -p "$artifact_path"
+          echo -e "$log" >> "$debug_path"
+
+          echo "DEBUG_PATH=$debug_path" >> "$GITHUB_ENV"
+          echo "GITHUB_SERVER_ARTIFACT_NAME=$artifact_path" >> "$GITHUB_ENV"
+
       - shell: bash
         env:
           MAX_SECONDS_FOR_DOCKER: ${{ inputs.MAX_SECONDS_FOR_DOCKER }}
           DOCASSEMBLECLI_VERSION: ${{ inputs.DOCASSEMBLECLI_VERSION }}
         run: |
-          # 💡ALK0001 INFO: Set environment variables
+          log="💡ALK0001 INFO: Set environment variables"
+          echo -e "\n$log" >> "$DEBUG_PATH" && echo "$log"
+
           echo "MAX_SECONDS_FOR_DOCKER=$MAX_SECONDS_FOR_DOCKER" >> $GITHUB_ENV
           echo "DOCASSEMBLECLI_VERSION=$DOCASSEMBLECLI_VERSION" >> $GITHUB_ENV
           echo "DA_ADMIN_API_KEY=abcd1234abcd1234abcd5678abdc5678" >> $GITHUB_ENV
@@ -63,7 +82,8 @@ runs:
         id: api_key_output_step
         shell: bash
         run: |
-          # 💡 ALK0002 INFO: Create GitHub step output variables
+          log="💡 ALK0002 INFO: Create GitHub step output variables"
+          echo -e "\n$log" >> "$DEBUG_PATH"
           echo "DOCASSEMBLE_DEVELOPER_API_KEY=$DA_ADMIN_API_KEY" >> "$GITHUB_OUTPUT"
           echo "DA_ADMIN_EMAIL=$DA_ADMIN_EMAIL" >> "$GITHUB_OUTPUT"
           echo "DA_ADMIN_PASSWORD=$DA_ADMIN_PASSWORD" >> "$GITHUB_OUTPUT"
@@ -73,16 +93,20 @@ runs:
           CONFIG: ${{ inputs.CONFIG_CONTENTS }}
         shell: bash
         run: |
-          # 💡 ALK0003 INFO: Get config
+          log="💡 ALK0003 INFO: Get config"
+          echo -e "\n$log" >> "$DEBUG_PATH"
+
           mkdir /tmp/config
           # Worth making this silent by defining a variable with > /dev/null...?
           if [ -n "$CONFIG" ]
           then
-            echo "💡 ALK0004 INFO: The developer did provide a custom docassemble config file as an input into this action."
+            log2="💡 ALK0004 INFO: The developer did provide a custom docassemble config file as an input into this action."
+            echo -e "\n$log2" >> "$DEBUG_PATH" echo "$log2"
             echo "$CONFIG" > /tmp/config/myconfig.yml
             echo "CONFIG_ARGS=--env DA_CONFIG=/tmp/config/myconfig.yml --volume /tmp/config:/tmp/config " >> $GITHUB_ENV
           else
-            echo "💡 ALK0005 INFO: The developer did NOT provide a custom docassemble config file as an input into this action. Docassemble will use its default config."
+            log3="💡 ALK0005 INFO: The developer did NOT provide a custom docassemble config file as an input into this action. Docassemble will use its default config."
+            echo -e "\n$log3" >> "$DEBUG_PATH" echo "$log3"
             echo "CONFIG_ARGS=" >> $GITHUB_ENV
           fi
 
@@ -97,11 +121,14 @@ runs:
           SHOW_DOCKER_OUTPUT: ${{ inputs.SHOW_DOCKER_OUTPUT }}
         shell: bash
         run: |
-          # 💡 ALK0006 INFO: Determine docker logs visibility
+          log="💡 ALK0006 INFO: Determine docker logs visibility"
+          echo -e "\n$log" >> "$DEBUG_PATH"
           if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
             echo "OUTPUT_DOCKER=$SHOW_DOCKER_OUTPUT" >> $GITHUB_ENV
+            echo -e "\n$SHOW_DOCKER_OUTPUT" >> "$DEBUG_PATH"
           else
             echo "OUTPUT_DOCKER=false" >> $GITHUB_ENV
+            echo -e "\nfalse" >> "$DEBUG_PATH"
           fi
 
       # Messages about output
@@ -110,13 +137,15 @@ runs:
         shell: bash
         run: |
           # 💡 ALK0007 INFO: ALKiln will now hide docker output
-          echo -e '===\n💡 ALK0007 INFO: ALKiln will now hide docker output to avoid possibly showing details about your config. If you want to get output to see more of what is going on, use "with:" and set the input "SHOW_DOCKER_OUTPUT" to "true". This output will only be visible to those who can already see the action output, like people with admin or write permissions.\n==='
+          log="===\n💡 ALK0007 INFO: ALKiln will now hide docker output to avoid possibly showing details about your config. If you want to get output to see more of what is going on, use \"with:\" and set the input \"SHOW_DOCKER_OUTPUT\" to \"true\". This output will only be visible to those who can already see the action output, like people with admin or write permissions.\n==="
+          echo -e "\n$log" >> "$DEBUG_PATH" && echo -e "$log"
       - name: "💡 ALK0008 INFO: ALKiln will show docker output"
         if: ${{ env.OUTPUT_DOCKER == 'true' }}
         shell: bash
         run: |
           # 💡 ALK0008 INFO: ALKiln will show docker output
-          echo -e '===\n💡 ALK0008 INFO: ALKiln will show docker output. ALKiln cannot control this output. If you want to prevent output, use "with:" and set the input "SHOW_DOCKER_OUTPUT" to "false". This output will only be visible to those who can already see the action output, like people with admin or write permissions.\n==='
+          log="===\n💡 ALK0008 INFO: ALKiln will show docker output. ALKiln cannot control this output. If you want to prevent output, use \"with:\" and set the input \"SHOW_DOCKER_OUTPUT\" to \"false\". This output will only be visible to those who can already see the action output, like people with admin or write permissions.\n==="
+          echo -e "\n$log" >> "$DEBUG_PATH" && echo -e "$log"
 
       # TODO: Reduce these to 1 block by putting ` > /dev/null 2>&1` into an env var
       # No docker output
@@ -126,13 +155,14 @@ runs:
           CONFIG_ARGS: ${{ env.CONFIG_ARGS }}
         shell: bash
         run: |
-          # 💡 ALK0009 INFO: Download and start docker silently
+          log="💡 ALK0009 INFO: Download and start docker silently"
+          echo -e "\n$log" >> "$DEBUG_PATH"
           docker pull jhpyle/docassemble > /dev/null 2>&1
           docker run --name docassemble_container \
                      --env DA_ADMIN_EMAIL="$DA_ADMIN_EMAIL" \
                      --env DA_ADMIN_PASSWORD="$DA_ADMIN_PASSWORD" \
                      --env DA_ADMIN_API_KEY="$DA_ADMIN_API_KEY" \
-                     $CONFIG_ARGS \
+                     "$CONFIG_ARGS" \
                      --cap-add SYS_PTRACE \
                      --memory="4gb" -d -p 80:80 jhpyle/docassemble > /dev/null 2>&1
       # With output
@@ -142,13 +172,14 @@ runs:
           CONFIG_ARGS: ${{ env.CONFIG_ARGS }}
         shell: bash
         run: |
-          # 💡 ALK0010 INFO: Download and start docker
+          log="💡 ALK0010 INFO: Download and start docker"
+          echo -e "\n$log" >> "$DEBUG_PATH"
           docker pull jhpyle/docassemble
           docker run --name docassemble_container \
                      --env DA_ADMIN_EMAIL="$DA_ADMIN_EMAIL" \
                      --env DA_ADMIN_PASSWORD="$DA_ADMIN_PASSWORD" \
                      --env DA_ADMIN_API_KEY="$DA_ADMIN_API_KEY" \
-                     $CONFIG_ARGS \
+                     "$CONFIG_ARGS" \
                      --cap-add SYS_PTRACE \
                      --memory="4gb" -d -p 80:80 jhpyle/docassemble
 
@@ -159,12 +190,14 @@ runs:
         shell: bash
         run: |
           # 💡 ALK0011 INFO: The following messages are not docker output
-          echo "💡 ALK0011 INFO: The following messages are not docker output, just ALKiln waiting for the server to start"
+          log="💡 ALK0011 INFO: The following messages are NOT docker output, just ALKiln waiting for the server to start"
+          echo -e "\n$log" >> "$DEBUG_PATH" && echo -e "$log"
 
       - name: "💡 ALK0012 INFO: Waiting for server to start"
         shell: bash
         run: |
-          # 💡 ALK0012 INFO: Waiting for server to start
+          log="💡 ALK0012 INFO: Waiting for server to start"
+          echo -e "\n$log" >> "$DEBUG_PATH"
 
           # Reset the SECONDS variable
           SECONDS=0
@@ -173,23 +206,28 @@ runs:
 
           response="start"
           while [[ $response != *"200"* ]]; do
-            echo "💡 ALK0013 INFO: Time elapsed: $SECONDS seconds"
+            log2="💡 ALK0013 INFO: Time elapsed: $SECONDS seconds"
+            echo -e "\n$log2" >> "$DEBUG_PATH" && echo -e "$log2"
 
             # Check if max seconds till loading has passed
             if [[ $SECONDS -ge $MAX_SECONDS_FOR_DOCKER ]]; then
-              echo "🤕 ALK0014 ERROR: Timed out waiting for docker container to serve the site. If you want to give your docker container more timem to install, set the MAX_SECONDS_FOR_DOCKER input for this action."
+              log3="🤕 ALK0014 ERROR: Timed out waiting for docker container to serve the site. If you want to give your docker container more timem to install, set the MAX_SECONDS_FOR_DOCKER input for this action."
+              echo -e "\n$log3" >> "$DEBUG_PATH" && echo -e "$log3"
               exit 1
             fi
 
             # Set the variable to a new string value in each iteration
             response=$(curl -o /dev/null -s -w "%{http_code}\n" http://localhost:80/health_check?ready=1)
-            echo "💡 ALK0015 INFO: Response is $response"
+            log4="💡 ALK0015 INFO: Response is $response"
+            echo -e "\n$log4" >> "$DEBUG_PATH" && echo -e "$log4"
 
             # Check if the string includes the desired text
             if [[ $response == *"200"* ]]; then
-              echo "🌈 ALK0016 SUCCESS: Success! The docker container is ready!"
+              log5="💡 ALK0016 SUCCESS: Success! The docker container is ready!"
+              echo -e "\n$log5" >> "$DEBUG_PATH" && echo -e "$log5"
             else
-              echo "💡 ALK0017 INFO: The docker container is not ready yet. Will check again in 30 seconds."
+              log6="💡 ALK0017 INFO: The docker container is not ready yet. Will check again in 30 seconds."
+              echo -e "\n$log6" >> "$DEBUG_PATH" && echo -e "$log6"
               sleep 30
             fi
 
@@ -219,32 +257,28 @@ runs:
 
       # Upload artifacts that devs can download on the Actions summary page
       # Only if the developer wants to get that info, though
-      - name: "💡 ALK0018 INFO: Get path names with date and time"
-        if: ${{ always() && env.OUTPUT_DOCKER == 'true' }}
-        shell: bash
-        run: |
-          # 💡 ALK0018 INFO: Get path names with date and time
-          echo "GITHUB_SERVER_LOG_FILE_NAME=/tmp/alkiln_docker_logs-$(date +'%Y-%m-%d at %Hh%Mm%Ss' -u)UTC.txt" >> $GITHUB_ENV
-          echo "GITHUB_SERVER_ARTIFACT_NAME=alkiln_github_server-$(date +'%Y-%m-%d at %Hh%Mm%Ss' -u)UTC" >> $GITHUB_ENV
       - name: "💡 ALK0019 INFO: Create docker artifact data"
         if: ${{ always() && env.OUTPUT_DOCKER == 'true' }}
         shell: bash
         run: |
-          # 💡 ALK0019 INFO: Create docker artifact data
-          echo "$(docker output docassemble_container)" > "${{ env.GITHUB_SERVER_LOG_FILE_NAME }}"
+          log="💡 ALK0019 INFO: Create docker artifact data"
+          echo -e "\n$log" >> "$DEBUG_PATH"
+          echo "$(docker output docassemble_container)" >> "${{ env.DEBUG_PATH }}"
       - name: "💡 ALK0020 INFO: Upload artifacts folder"
         if: ${{ always() && env.OUTPUT_DOCKER == 'true' }}
         uses: actions/upload-artifact@v4
         with:
           name: ${{ env.GITHUB_SERVER_ARTIFACT_NAME }}
-          path: ${{ env.GITHUB_SERVER_LOG_FILE_NAME }}
+          path: ${{ env.DEBUG_PATH }}
 
       - shell: bash
         if: ${{ success() }}
         run: |
-          echo "🌈 ALK0021 SUCCESS: ALKiln created the docker container and started the server!"
+          log="💡 ALK0021 SUCCESS: ALKiln created the docker container and started the server!"
+          echo -e "\n$log" >> "$DEBUG_PATH" && echo -e "$log"
 
       - shell: bash
         if: ${{ failure() }}
         run: |
-          echo "🤕 ALK0022 ERROR: Something went wrong. See above for more details."
+          log="🤕 ALK0022 ERROR: Something went wrong. See above for more details."
+          echo -e "\n$log" >> "$DEBUG_PATH" && echo -e "$log"

package/docs/decisions/006_which_log_level_to_pick_2024_09_5.md

@@ -0,0 +1,46 @@
+# Which log levels to pick
+
+## Context and Problem Statement
+
+The log levels we're giving access to in Log are `success` (`info` with a special icon), `info`, `warn`, and `throw` (`error` and throw the error). Sometimes, like in the log file itself, we hard-code the icons and such. Those places have access to other levels, like `error`.
+
+We want to avoid distracting our users by logging errors everywhere, even when an error is what triggered the log. Does that hold true in the debug log? Successes can also be misleading about whether tests have passed or not.
+
+When picking the log level for a log, how do we know which level to choose?
+
+## Considered Options
+
+- Stay as true to technical behavior as possible.
+- Stay as clear to users as possible - use levels that will help users pay attention to what affects them.
+
+For example:
+
+`success`:
+  - Use whenever anything completes successfully.
+  - Only use for success of major operations.
+  - Use for every test success.
+  - Use for success of all the tests.
+`error`:
+- Always use `error` when an error happens.
+- Use `error` when an unexpected error happens.
+- Only use `error` for user-relevant errors.
+
+
+## Decision Outcome
+
+Distract the user as little as possible everywhere.
+
+`success`:
+  - Only log success once for success of all tests.
+  - Include the `success` icon in the Scenario "Passed" section of the report.
+`throw`:
+  - Use this level to throw errors for the user's tests (or our own internal tests).
+  - Use this if ALKiln itself needs to abort a test or the test suite.
+`error`:
+  - Avoid using `error` explicitly. Only the debug logs should use the `error` level, and only to record critical errors that come in with `throw`.
+`info`:
+  - Log expected errors as `info`. For example, the aborted promises when awaiting navigation.
+`warn`:
+  - Avoid using the word "error" in warnings if possible.
+  - Use `warn` in the console for messages the user should investigate.
+  - Use `warn` in the debug log for messages ALKiln devs might investigate if necessary. If the warning comes from non-critical unexpected behavior, do try to be clear about what happened, but also try to avoid using the word "error" if possible. E.g. "Skipped creating metadata for the logs" instead of "Error while creating metadata for the logs".

package/docs/decisions/adopt_architectural_decision_records.md

@@ -0,0 +1,58 @@
+# Document decisions
+
+## Context and Problem Statement
+
+What is a good way to avoid re-hashing old decisions, or to at least know why those decisions were made?
+
+## Considered Options
+
+- GitHub issues
+- GitHub discussions
+- Actual files in the repo
+
+Formats:
+- https://adr.github.io/madr
+
+
+## Decision Outcome
+
+Use in-repo .md files using the https://adr.github.io/madr format. We found keeping the data within the repo to be the most compelling factor.
+
+## Pros and Cons of the Options
+
+### GitHub issues
+
+Pros:
+
+- Easy to search.
+- Can add labels and such.
+- In one of the most common places to search.
+- Allows comments
+
+Cons:
+
+- Not actually in the repository, so any forks or clones would lose that info.
+- Comments can get confusing and hard to read.
+
+### GitHub discussions
+
+Pros:
+
+- Labels and such.
+- Probably easy to search?
+
+Cons:
+
+- A separate place from issues. Not everyone even knows those exist.
+- All the cons of GitHub issues
+
+### Actual files in the repo
+
+Pros:
+
+- They go everywhere the repo goes.
+
+Cons:
+
+- Probably not as searchable, though maybe we could institute a way to "label"/tag them.
+- Not very visible.