You are working on a project and your job is to implement new code changes based on given instructions.
Now you have to implement ALL changes that are related to `/path/to/logs/application_log.txt` described in development instructions listed below.
Make sure you don't make any mistakes, especially ones that could affect rest of project. Your changes will be reviewed by very detailed reviewer. Because of that, it is extremely important that you are STRICTLY following ALL the following rules while implementing changes:

# RULES FOR IMPLEMENTING CODE CHANGES
---start_of_coding_rules---

## Rule 1: Scope of your coding task
You must implement everything mentioned in the instructions that is related to this file. It can happen that instruction mention code changes needed in this file on multiple places and all of them have to be implemented now. We will not make any other changes to this file before the review and finishing this task.

## Rule 2: Output format
You must output the COMPLETE NEW VERSION of this file in following format:
---start_of_format---
```
the full contents of the updated file, without skipping over any content
```
---end_of_format---

## Rule 3: Comprehensive Codebase Insight
It's crucial to grasp the full scope of the codebase related to your tasks to avert mistakes. Check the initial conversation message for a list of files. Pay a lot of attention to files that are directly included in the file you are currently modifying or that are importing your file.
Consider these examples to guide your approach and thought process:
---start_of_examples---
- UI components or templates: Instead of placing scripts directly on specific pages, integrating them in the <head> section or as reusable partials enhances application-wide consistency and reusability.
- Database operations: Be careful not to execute an action, like password hashing, both in a routing function and a model's pre('save') hook, which could lead to redundancy and errors.
- Adding backend logic: Prior to creating new functions, verify if an equivalent function exists in the codebase that you could import and use, preventing unnecessary code duplication and keeping the project efficient.
---end_of_examples---

## Rule 4: Coding principles
Write high-quality code, first organize it logically with clear, meaningful names for variables, functions, and classes. Aim for simplicity and adhere to the DRY (Don't Repeat Yourself) principle to avoid code duplication. Pay attention not to duplicate the code that's present in other files, contents of which are below. Ensure your codebase is structured and modular for easy navigation and updates.

If the instructions have comments like `// ..add code here...` or `# placeholder for code`, instead of copying the comment, interpret the instructions and output the relevant code.

Your reply MUST NOT omit any code in the new implementation or substitute anything with comments like `// .. rest of the code goes here ..` or `# insert existing code here`, because I will overwrite the existing file with the content you provide. Output ONLY the content for this file, without additional explanation, suggestions or notes. Your output MUST start with ``` and MUST end with ``` and include only the complete file contents.

When working with configuration files (e.g. config.json, .env,...), for hardcoded configuration values that the user needs to change, mark the line that needs user configuration with `INPUT_REQUIRED {config_description}` comment,  where `config_description` is a description of the value that needs to be set by the user. Use appropriate syntax for comments in the file you're saving (for example `// INPUT_REQUIRED {config_description}` in JavaScript). NEVER ask the user to write code or provide implementation, even if the instructions suggest it! If the file type doesn't support comments (eg JSON), don't add any.

## Rule 5: Logging
Whenever you write code, make sure to log code execution so that when a developer looks at the CLI output, they can understand what is happening on the server. If the description above mentions the exact code that needs to be added but doesn't contain enough logs, you need to add the logs handlers inside that code yourself.

## Rule 6: Error handling
Whenever you write code, make sure to add error handling for all edge cases you can think of because this app will be used in production so there shouldn't be any crashes. Whenever you log the error, you **MUST** log the entire error message and trace and not only the error message. If the description above mentions the exact code that needs to be added but doesn't contain enough error handlers, you need to add the error handlers inside that code yourself.

---end_of_coding_rules---

You are currently working on this task:
```
Conduct a comprehensive requirements gathering session with stakeholders to understand the project's needs and objectives.
```


Here are development instructions and now you have to focus only on changes in `/path/to/logs/application_log.txt`:
---start_of_development_instructions---

There are no files provided for review after the task's implementation, and no files before the task started. Therefore, I do not have enough information to conduct a review based on the specified criteria: removed functionalities, unused new files or functions, dead code, or duplicate code.

Without the relevant files or their contents, I cannot execute the review as required. Please provide the complete content of the files after the task implementation or the changes made to check against the criteria.

---end_of_development_instructions---

You need to create a new file `/path/to/logs/application_log.txt`.

These files are currently implemented in the project:
* `.eslintrc.cjs: Configuration file for ESLint, a static code analysis tool for identifying problematic patterns found in JavaScript code. It defines rules for linting JavaScript code with a focus on React applications.`
* `.gitignore: Specifies patterns to exclude files and directories from being tracked by Git version control system. It is used to prevent certain files from being committed to the repository.`
* `README.md: This file is responsible for handling user authentication in the application. It includes classes and functions for login, logout, and registration processes. Major functionalities include validating user credentials, hashing passwords, and managing user sessions. The file also defines decorators for access control and manages user authentication state throughout the application.`
* `index.html: Main entry point for the project. It includes a basic HTML structure with a root div element and a script tag importing a JavaScript file named main.jsx using the module type. References: src/main.jsx`
* `package.json: Standard Nodejs package metadata file, specifies dependencies and start scripts. It also specifies that the project is a module.`
* `public/.gitkeep: Empty file`
* `src/App.css: Contains styling rules for the root element of the application, setting a maximum width, centering it on the page, adding padding, and aligning text to the center.`
* `src/App.jsx: Defines a functional component that serves as the root component in the project. The component is exported as the default export. References: src/App.css`
* `src/assets/.gitkeep: Empty file`
* `src/index.css: Defines styling rules for the root element, body, and h1 elements of a web page.`
* `src/main.jsx: Main entry point for a React application. It imports necessary modules, renders the main component 'App' inside a 'React.StrictMode' component, and mounts it to the root element in the HTML document. References: App.jsx, index.css`
* `vite.config.js: Configuration file for Vite, a fast developer-friendly Javascript bundler/devserver.`

Here are the complete contents of files relevant to this task:
---START_OF_FILES---
---END_OF_FILES---