Update getting started according to new app template

014-docs.md

@@ -25,26 +25,37 @@ The guide should follow [Micosoft style guide](https://learn.microsoft.com/en-us
 
 ## Blocks
 
-Blocks use the Markdown `> Type: `. There are four block types:
+Blocks are in the [GitHub Alerts format](https://docs.github.com/en/get-started/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax#alerts):
 
-* `Warning`, for bad security things and other problems
-* `Note`, to emphasize key concepts, things to avoid
-* `Info`, general information (an aside); not as strong as a "Note"
-* `Tip`, pro tips, extras. It can be useful but may not be needed by everyone all the time
+```
+> [!NOTE]
+> Useful information that users should know, even when skimming content.
+
+> [!TIP]
+> Helpful advice for doing things better or more easily.
+
+> [!IMPORTANT]
+> Key information users need to know to achieve their goal.
 
-The sentence after the colon should begin with a capital letter.
+> [!WARNING]
+> Urgent info that needs immediate user attention to avoid problems.
+
+> [!CAUTION]
+> Advises about risks or negative outcomes of certain actions.
+```
 
 When translating documentation, these Block indicators should not be translated.
 Keeps them intact as they are and only translate the block content.
-For translating the `Type` word, each guide translation should have a `blocktypes.json` file
+For translating the label for the block, each guide translation should have a `blocktypes.json` file
 containing the translations. The following shows an example for German:
 
 ```json
 {
-    "Warning:": "Achtung:",
-    "Note:": "Hinweis:",
-    "Info:": "Info:",
-    "Tip:": "Tipp:"
+    "Note": "Hinweis",
+    "Tip": "Tipp",
+    "Important": "Wichtig",
+    "Warning": "Achtung",
+    "Caution": "Vorsicht"
 }
 ```
 

015-phpstorm.md

@@ -12,7 +12,8 @@ We use the following set of coding styles for metadata.
 - Metadata should be placed in `/.phpstorm.meta.php` directory.
 - Configuration should be split into files. Each file should be named after a class it configures.
 
-> Note: There is no support for subdirectories in PhpStorm yet.
+> [!NOTE]
+> There is no support for subdirectories in PhpStorm yet.
 
 ### Constants 
 

cookbook/en/README.md

@@ -15,3 +15,4 @@ This book conforms to the [Terms of Yii Documentation](https://www.yiiframework.
 - [Preface](preface.md)
 - [Structuring code by use-case with vertical slices](organizing-code/structuring-by-use-case-with-vertical-slices.md)
 - [Sentry integration](sentry-integration.md)
+- [Configuring webservers](configuring-webservers/general.md)

cookbook/en/configuring-webservers/apache.md

@@ -0,0 +1,46 @@
+# Configuring web servers: Apache
+
+Use the following configuration in Apache's `httpd.conf` file or within a virtual host configuration. Note that you
+should replace `path/to/app/public` with the actual path for `app/public`.
+
+```apacheconfig
+# Set document root to be "app/public"
+DocumentRoot "path/to/app/public"
+
+<Directory "path/to/app/public">
+    # use mod_rewrite for pretty URL support
+    RewriteEngine on
+
+    # if $showScriptName is false in UrlManager, do not allow accessing URLs with script name
+    RewriteRule ^index.php/ - [L,R=404]
+
+    # If a directory or a file exists, use the request directly
+    RewriteCond %{REQUEST_FILENAME} !-f
+    RewriteCond %{REQUEST_FILENAME} !-d
+
+    # Otherwise forward the request to index.php
+    RewriteRule . index.php
+
+    # ...other settings...
+</Directory>
+```
+
+In case you have `AllowOverride All` you can add `.htaccess` file with the following configuration instead of
+using `httpd.conf`:
+
+```apacheconfig
+# use mod_rewrite for pretty URL support
+RewriteEngine on
+
+# if $showScriptName is false in UrlManager, do not allow accessing URLs with script name
+RewriteRule ^index.php/ - [L,R=404]
+
+# If a directory or a file exists, use the request directly
+RewriteCond %{REQUEST_FILENAME} !-f
+RewriteCond %{REQUEST_FILENAME} !-d
+
+# Otherwise forward the request to index.php
+RewriteRule . index.php
+
+# ...other settings...
+```

cookbook/en/configuring-webservers/general.md

@@ -0,0 +1,16 @@
+# Configuring web servers: General
+
+On a production server, if you don't use Docker, configure your web server to serve only the application's public files. 
+Point the document root of your web server to the `app/public` folder.
+
+> [!IMPORTANT]
+> If you're running your Yii application behind a reverse proxy, you might need to configure
+> [Trusted proxies and headers](../../../guide/en/security/trusted-request.md).
+
+## Specific server configurations
+
+- [Nginx](nginx.md)
+- [Apache](apache.md)
+- [Lighttpd](lighttpd.md)
+- [Nginx Unit](nginx-unit.md)
+- [IIS](iis.md)

cookbook/en/configuring-webservers/iis.md

@@ -0,0 +1,34 @@
+# Configuring web servers: IIS
+
+When you use [IIS](https://www.iis.net/), host the application in a virtual host (Website) where the document
+root points to the `path/to/app/public` folder and configure the website to run PHP.
+In that `public` folder, place a file named `web.config` at `path/to/app/public/web.config`.
+Use the following content:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+<system.webServer>
+<directoryBrowse enabled="false" />
+  <rewrite>
+    <rules>
+      <rule name="Hide Yii Index" stopProcessing="true">
+        <match url="." ignoreCase="false" />
+        <conditions>
+        <add input="{REQUEST_FILENAME}" matchType="IsFile" 
+              ignoreCase="false" negate="true" />
+        <add input="{REQUEST_FILENAME}" matchType="IsDirectory" 
+              ignoreCase="false" negate="true" />
+        </conditions>
+        <action type="Rewrite" url="index.php" appendQueryString="true" />
+      </rule> 
+    </rules>
+  </rewrite>
+</system.webServer>
+</configuration>
+```
+
+Also, the following list of Microsoft's official resources could be useful to configure PHP on IIS:
+
+1. [How to set up your first IIS website](https://support.microsoft.com/en-us/help/323972/how-to-set-up-your-first-iis-web-site)
+2. [Configure a PHP Website on IIS](https://docs.microsoft.com/en-us/iis/application-frameworks/scenario-build-a-php-website-on-iis/configure-a-php-website-on-iis)

cookbook/en/configuring-webservers/lighttpd.md

@@ -0,0 +1,7 @@
+# Configuring web servers: lighttpd
+
+To use [lighttpd](https://www.lighttpd.net/) >= 1.4.24, put `index.php` in the web root and add the following to the configuration:
+
+```
+url.rewrite-if-not-file = ("(.*)" => "/index.php/$0")
+```

cookbook/en/configuring-webservers/nginx-unit.md

@@ -0,0 +1,60 @@
+# Configuring web servers: NGINX Unit
+
+Run Yii-based apps using [NGINX Unit](https://unit.nginx.org/) with a PHP language module.
+Here is a sample configuration.
+
+```json
+{
+    "listeners": {
+        "*:80": {
+            "pass": "routes/yii"
+        }
+    },
+
+    "routes": {
+        "yii": [
+            {
+                "match": {
+                    "uri": [
+                        "!/assets/*",
+                        "*.php",
+                        "*.php/*"
+                    ]
+                },
+
+                "action": {
+                    "pass": "applications/yii/direct"
+                }
+            },
+            {
+                "action": {
+                    "share": "/path/to/app/public/",
+                    "fallback": {
+                        "pass": "applications/yii/index"
+                    }
+                }
+            }
+        ]
+    },
+
+    "applications": {
+        "yii": {
+            "type": "php",
+            "user": "www-data",
+            "targets": {
+                "direct": {
+                    "root": "/path/to/app/public/"
+                },
+
+                "index": {
+                    "root": "/path/to/app/public/",
+                    "script": "index.php"
+                }
+            }
+        }
+    }
+}
+```
+
+You can also [set up](https://unit.nginx.org/configuration/#php) your PHP environment or supply a custom `php.ini`
+in the same configuration.

cookbook/en/configuring-webservers/nginx.md

@@ -0,0 +1,56 @@
+# Configuring web servers: Nginx
+
+To use [Nginx](https://wiki.nginx.org/), install PHP as an [FPM SAPI](https://secure.php.net/install.fpm).
+Use the following Nginx configuration, replacing `path/to/app/public` with the actual path for
+`app/public` and `mysite.test` with the actual hostname to serve.
+
+```nginx
+server {
+    charset utf-8;
+    client_max_body_size 128M;
+
+    listen 80; ## listen for ipv4
+    #listen [::]:80 default_server ipv6only=on; ## listen for ipv6
+
+    server_name mysite.test;
+    root        /path/to/app/public;
+    index       index.php;
+
+    access_log  /path/to/basic/log/access.log;
+    error_log   /path/to/basic/log/error.log;
+
+    location / {
+        # Redirect everything that isn't a real file to index.php
+        try_files $uri $uri/ /index.php$is_args$args;
+    }
+
+    # uncomment to avoid processing of calls to non-existing static files by Yii
+    #location ~ \.(js|css|png|jpg|gif|swf|ico|pdf|mov|fla|zip|rar)$ {
+    #    try_files $uri =404;
+    #}
+    #error_page 404 /404.html;
+
+    # deny accessing php files for the /assets directory
+    location ~ ^/assets/.*\.php$ {
+        deny all;
+    }
+
+    location ~ \.php$ {
+        include fastcgi_params;
+        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+        fastcgi_pass 127.0.0.1:9000;
+        #fastcgi_pass unix:/var/run/php8-fpm.sock;
+        try_files $uri =404;
+    }
+
+    location ~* /\. {
+        deny all;
+    }
+}
+```
+
+When you use this configuration, also set `cgi.fix_pathinfo=0` in the `php.ini` file
+to avoid many unnecessary system `stat()` calls.
+
+Also, note that when running an HTTPS server, you need to add `fastcgi_param HTTPS on;` so that Yii
+can detect if a connection is secure.

cookbook/en/preface.md

@@ -2,16 +2,15 @@
 
 Yii is a high-performance, package-based PHP framework for developing modern applications.
 The name Yii (pronounced `Yee` or `[ji:]`) means "simple and evolutionary" in Chinese.
 You can also think about it as an acronym for **Yes It Is**!
 
 Yii is a generic Web programming framework.
 You can use it for developing all kinds of Web applications using PHP.
 Because of its architecture and sophisticated caching support,
 it's especially suitable for developing large-scale applications such as portals, content management systems,
 e-commerce, REST APIs, etc.
 
-Together with a comprehensive set of documentation and an enthusiastic user community, Yii can reduce your development
-time in a long run significantly.
+With comprehensive documentation and an enthusiastic user community, Yii can significantly reduce your development time in the long run.
 
 ## What's the book about
 

guide/en/README.md

@@ -1,6 +1,6 @@
 # The definitive guide to Yii 3.0
 
-This guide is released under the [Terms of Yii Documentation](https://www.yiiframework.com/license#docs).
+We release this guide under the [Terms of Yii Documentation](https://www.yiiframework.com/license#docs).
 
 Introduction +
 ------------
@@ -46,7 +46,7 @@
 Handling requests +
 -----------------
 
 * [Routing and URL generation](runtime/routing.md) +
 * [Request](runtime/request.md) +
 * [Response](runtime/response.md) +
 * [Sessions](runtime/sessions.md) +
@@ -71,7 +71,7 @@
 
 * [Database access objects](db-dao.md): Connecting to a database, basic queries, transactions, and schema manipulation
 * [Query builder](db-query-builder.md): Querying the database using a simple abstraction layer
 * [Active record](db-active-record.md): The Active Record ORM, retrieving and manipulating records, and defining relations
 * [Migrations](databases/db-migrations.md): +
 
 Getting data from users -
@@ -113,7 +113,7 @@
 * [HTTP caching](caching/http.md) -
 
 
 REST APIs -
 -----------
 
 * [Quick start](rest/quick-start.md)

guide/en/caching/data.md

@@ -34,37 +34,38 @@
 
 ## Cache handlers
 
 The cache service uses [PSR-16](https://www.php-fig.org/psr/psr-16/) compatible cache handlers which represent various
 cache storages, such as memory, files, and databases.
 
 Yii provides the following handlers:
 
 - `NullCache` — a cache placeholder which does no real caching. The purpose of this handler is to simplify
   the code that needs to check the availability of cache. For example, during development or if the server doesn't have
   actual cache support, you may configure a cache service to use this handler.
   When you enable actual cache support, you can switch to using the corresponding cache handler.
   In both cases, you may use the same code without extra checks.
 - `ArrayCache` — provides caching for the current request only by storing the values in an array.
 - [APCu](https://github.com/yiisoft/cache-apcu) - uses a PHP [APC](https://secure.php.net/manual/en/book.apc.php) extension.
   You can consider this option as the fastest one when dealing with cache for a centralized thick application (e.g., one
   server, no dedicated load balancers, etc.).
 - [Database](https://github.com/yiisoft/cache-db) — uses a database table to store cached data.
 - [File](https://github.com/yiisoft/cache-file) — uses standard files to store cached data. This is particularly suitable
   to cache large chunks of data, such as page content.
 - [Memcached](https://github.com/yiisoft/cache-memcached) — uses a PHP [memcached](https://secure.php.net/manual/en/book.memcached.php)
   extension. You can consider this option as the fastest one when dealing with cache in distributed application 
   (e.g., with several servers, load balancers, etc.)
 - [Wincache](https://github.com/yiisoft/cache-wincache) — uses PHP [WinCache](https://iis.net/downloads/microsoft/wincache-extension)
   ([see also](https://secure.php.net/manual/en/book.wincache.php)) extension.
 
 [You could find more handlers at packagist.org](https://packagist.org/providers/psr/simple-cache-implementation).
 
-> Tip: You may use different cache storage in the same application. A common strategy is:
+> [!TIP]
+> You may use different cache storage in the same application. A common strategy is:
 > - To use memory-based cache storage to store small but constantly used data (e.g., statistics)
 > - To use file-based or database-based cache storage to store big and less often used data (e.g., page content)
 
 Cache handlers are usually set up in a [dependency injection container](../concept/di-container.md) so that they can
 be globally configurable and accessible. 
 
 Because all cache handlers support the same set of APIs, you can swap the underlying cache handler
 with a different one. You can do it by reconfiguring the application without modifying the code that uses the cache.
@@ -93,7 +94,7 @@
 
 A data item stored in a cache will remain there forever unless it's removed because of some caching policy
 enforcement. For example, caching space is full and cache storage removes the oldest data.
 To change this behavior, you can set a TTL parameter when calling a method to store a data item:
 
 ```php
 $ttl = 3600;
@@ -106,7 +107,7 @@
 the data item, if it has passed the expiration time, the method will execute the function and set the resulting value
 into cache.
 
 You may set default TTL for the cache:
 
 ```php
 $cache = new \Yiisoft\Cache\Cache($arrayCache, 60 * 60); // 1 hour
@@ -151,7 +152,7 @@
   is different.
 - `\Yiisoft\Cache\Dependency\FileDependency`: invalidates the cache when the file's last modification time is different.
 - `\Yiisoft\Cache\Dependency\TagDependency`: associates a cached data item with one or many tags. You may invalidate
   the cached data items with the specified tag(s) by calling `TagDependency::invalidate()`.
 
 You may combine many dependencies using `\Yiisoft\Cache\Dependency\AnyDependency` or `\Yiisoft\Cache\Dependency\AllDependencies`.
 
@@ -164,8 +165,8 @@
 This behavior is sometimes also called dog-piling.
 
 The `\Yiisoft\Cache\Cache` uses a built-in "Probably early expiration" algorithm that prevents cache stampede.
 This algorithm randomly fakes a cache miss for one user while others are still served the cached value.
 You can control its behavior with the fifth optional parameter of `getOrSet()`, which is a float value called `$beta`.
 By default, beta is `1.0`, which is usually enough.
 The higher the value the earlier cache will be re-created.
 

guide/en/concept/aliases.md

@@ -1,15 +1,15 @@
 # Aliases
 
 You can use aliases to represent file paths or URLs so that you don't have to hard-code absolute paths or URLs in your
 project. An alias must start with the `@` character to be differentiated from normal file paths and URLs. Alias defined
 without leading `@` will be prefixed with `@` character.
 
 Default Yii application has some aliases pre-defined in `config/params.php`. For example, the alias `@public` represents
 the web root path; `@baseUrl` represents the base URL for the currently running Web application.
 
 ## Defining aliases <span id="defining-aliases"></span>
 
 You can define an alias via application's `config/params.php`:
 
 ```php
 return [
@@ -32,12 +32,13 @@
 ];
 ```
 
-> Note: The file path or URL being aliased may *not* necessarily refer to an existing file or resource.
+> [!NOTE]
+> The file path or URL being aliased may *not* necessarily refer to an existing file or resource.
 
 Given a defined alias, you may derive a new alias by appending a slash `/` followed with one or more path segments.
 For example, `@foo` is a root alias, while `@foo/bar/file.php` is a derived alias.
 
 You can define an alias using another alias (either root or derived):
 
 ```php
 '@foobar' => '@foo/bar', 
@@ -78,7 +79,7 @@
 
 ## Resolving aliases <span id="resolving-aliases"></span>
 
 You can use `Aliases` service to resolve an alias or derived alias into the file path or URL it represents:
 
 ```php
 use \Yiisoft\Aliases\Aliases;
@@ -91,15 +92,16 @@
 }
 ```
 
 The path/URL represented by a derived alias is determined by replacing the root alias part with its corresponding
 path/URL in the derived alias.
 
-> Note: The `get()` method doesn't check whether the resulting path/URL refers to an existing file or resource.
+> [!NOTE]
+> The `get()` method doesn't check whether the resulting path/URL refers to an existing file or resource.
 
 
 A root alias may also contain slash `/` characters. The `get()` method
 is intelligent enough to tell, which part of an alias is a root alias and thus correctly determines
 the corresponding file path or URL:
 
 ```php
 use \Yiisoft\Aliases\Aliases;
@@ -114,7 +116,7 @@
 } 
 ```
 
 If `@foo/bar` isn't defined as a root alias, the last statement would display `/path/to/foo/bar/file.php`.
 
 
 ## Predefined aliases <span id="predefined-aliases"></span>
@@ -123,12 +125,12 @@
 
 - `@root` - the base directory of the currently running application.
 - `@assets` - application's public directory where it publishes assets.
 - `@assetsUrl` - URL of base directory with published assets.
 - `@baseUrl` - the base URL of the currently running Web application. Defaults to `/`.
 - `@npm` - node packages directory.
 - `@bower` - bower packages directory.
 - `@vendor` - Composer's `vendor` directory.
 - `@public` - application's publicly accessible directory that with `index.php`.
 - `@runtime` - the runtime path of the currently running application. Defaults to `@root/runtime`.
 - `@layout` - the directory with layouts.
 - `@resources` - directory with views, asset sources and other resources.

guide/en/concept/configuration.md

@@ -1,6 +1,6 @@
 # Configuration
 
 There are many ways to configure your application. We will focus on concepts used in
 the [default project template](https://github.com/yiisoft/app).
 
 Yii3 configs are part of the application. You can change many aspects of how the application works by editing
@@ -8,15 +8,15 @@
 
 ## Config plugin
 
 In the application template [yiisoft/config](https://github.com/yiisoft/config) is used. Since writing all application
 configurations from scratch is a tedious process, many packages offer default configs, and the plugin helps with
 copying these into the application.
 
 To offer default configs, `composer.json` of the package has to have `config-plugin` section.
 When installing or updating packages with Composer, the plugin reads `config-plugin` sections for each dependency,
 copies files themselves to application `config/packages/` if they don't yet exist and writes a merge plan to
 `config/packages/merge_plan.php`. The merge plan defines how to merge the configs into a single big array
 ready to be passed to [DI container](di-container.md).
 
 Take a look at what's in the "yiisoft/app" `composer.json` by default:
 
@@ -107,7 +107,7 @@
 
 The application consists of a set of services registered in a [dependency container](di-container.md). The config files
 that responsible for direct dependency container configuration are under `common/`, `console/` and `web/` directories.
 We use `web/` for config specific to web application and `console/` for config specific to console commands. Both web and
 console are sharing configuration under `common/`.
 
 ```php
@@ -220,7 +220,7 @@
 ];
 ``` 
 
 Read more about it in ["Routes"](../runtime/routing.md).
 
 ### Events
 
@@ -258,15 +258,16 @@
 ];
 ```
 
 Read more about it in ["Events"](events.md).
 
 
 ### Parameters
 
 Parameters, `config/params.php` store configuration values that are used in other config files to configuring services
 and service providers.
 
-> Tip: Don't use parameters, constants or environment variables directly in your application, configure
+> [!TIP]
+> Don't use parameters, constants or environment variables directly in your application, configure
 > services instead.
 
 Default application `params.php` looks like the following:
@@ -334,9 +335,9 @@
 
 Config plugin described copy default package configurations to `packages/` directory. Once copied you
 own the configs, so you can adjust these as you like. `yiisoft/` in the default template stands for package vendor. Since
 only `yiisoft` packages are in template, there's a single directory. `merge_plan.php` is used in runtime to get the order
 on how configs are merged.
 Note that for config keys there should be a single source of truth.
 One config can't override values of another config.
 
 `dist.lock` is used by the plugin to keep track of changes and display diff between current config and example one. 

guide/en/runtime/logging.md

@@ -1,6 +1,6 @@
 # Logging
 
 Yii relies on [PSR-3 interfaces](https://www.php-fig.org/psr/psr-3/) for logging, so you could configure any PSR-3
 compatible logging library to do the actual job.
 
 Yii provides its own logger that's highly customizable and extensible.
@@ -11,13 +11,13 @@
 
 * Record [log messages](#log-messages) at various places in your code;
 * Configure [log targets](#log-targets) in the application configuration to filter and export log messages;
 * Examine the filtered logged messages exported by different targets (e.g. the [Yii debugger](../tool/debugger.md)).
 
 In this section, the focus in on the first two steps.
 
 ## Log Messages <span id="log-messages"></span>
 
 To record log messages, you need an instance of PSR-3 logger.
 A class that writes log messages should receive it as a dependency:
 
 ```php
@@ -35,11 +35,11 @@
 Recording a log message is as simple as calling one of the following logging methods that correspond to log levels:
 
 - `emergency` - System is unusable.
 - `alert` - Action must be taken immediately.
   Example: Entire website down, database unavailable, etc.
   This should trigger the SMS alerts and wake you up.
 - `critical` - Critical conditions. Example: Application component unavailable, unexpected exception.
 - `error` - Runtime errors that don't require immediate action but should typically be logged and monitored.
 - `warning` - Exceptional occurrences that aren't errors. Example: Use of deprecated APIs, poor use of an API,
   undesirable things that aren't necessarily wrong.
 - `notice` - Normal but significant events.
@@ -78,20 +78,21 @@
 
 The `__METHOD__` constant evaluates as the name of the method (prefixed with the fully qualified class name) where 
 the constant appears.
 For example, it's equal to the string `'App\\Service\\MyService::serve'` if the above line of code is called within
 this method.
 
-> Info: The logging methods described above are actually shortcuts to the [[\Psr\Log\LoggerInterface::log()]].
+> [!IMPORTANT]
+> The logging methods described above are actually shortcuts to the [[\Psr\Log\LoggerInterface::log()]].
 
 Note that PSR-3 package provides `\Psr\Log\NullLogger` class that provides the same set of methods but doesn't log
 anything. That means that you don't have to check if logger is configured with `if ($logger !== null)` and, instead,
 can assume that logger is always present.
 
 
 ## Log targets <span id="log-targets"></span>
 
 A log target is an instance of a class that extends the [[\Yiisoft\Log\Target]]. It filters the log messages by their
 severity levels and categories and then exports them to some medium. For example,
 a [[\Yiisoft\Log\Target\File\FileTarget|file target]]exports the filtered log messages to a file,
 while a [[Yiisoft\Log\Target\Email\EmailTarget|email target]] exports the log messages to specified email addresses.
 
@@ -113,26 +114,26 @@
 ]);
 ```
 
 In the above code, two log targets are registered: 
 
 * the first target selects error and warning messages and writes them to `/path/to/app.log` file;
 * the second target selects emergency, alert, and critical messages under the categories whose names start with
 `Yiisoft\Cache\`, and sends them in an email to both `[email protected]` and `[email protected]`.
 
 Yii comes with the following built-in log targets. Please refer to the API documentation about these classes to 
 learn how to configure and use them. 
 
 * [[\Yiisoft\Log\PsrTarget]]: passes log messages to another PSR-3 compatible logger.
 * [[\Yiisoft\Log\StreamTarget]]: writes log messages into a specified output stream.
 * [[\Yiisoft\Log\Target\Db\DbTarget]]: saves log messages in database.
 * [[\Yiisoft\Log\Target\Email\EmailTarget]]: sends log messages to pre-specified email addresses.
 * [[\Yiisoft\Log\Target\File\FileTarget]]: saves log messages in files.
 * [[\Yiisoft\Log\Target\Syslog\SyslogTarget]]: saves log messages to syslog by calling the PHP function `syslog()`.
 
 In the following, we will describe the features common to all log targets.
 
 
 ### Message Filtering <span id="message-filtering"></span>
 
 For each log target, you can configure its levels and categories to specify 
 which severity levels and categories of the messages the target should process.
@@ -142,7 +143,7 @@
 By default, the target will process messages of *any* severity level.
 
 The target `setCategories()` method takes an array consisting of message category names or patterns.
 A target will only process messages whose category can be found or match one of the patterns in this array.
 A category pattern is a category name prefix with an asterisk `*` at its end. A category name matches a category pattern
 if it starts with the same prefix of the pattern. For example, `Yiisoft\Cache\Cache::set` and `Yiisoft\Cache\Cache::get`
 both match the pattern `Yiisoft\Cache\*`.
@@ -151,8 +152,8 @@
 
 Besides allowing the categories by the `setCategories()` method, you may also
 deny certain categories by the `setExcept()` method.
 If the category of a message is found or matches one of the patterns in this property,
 the target will NOT process it.
 
 The following target configuration specifies that the target should only process error and warning messages
 under the categories whose names match either `Yiisoft\Cache\*` or `App\Exceptions\HttpException:*`,
@@ -165,7 +166,7 @@
 $fileTarget->setExcept(['App\Exceptions\HttpException:404']);
 ```
 
 ### Message Formatting <span id="message-formatting"></span>
 
 Log targets export the filtered log messages in a certain format.
 For example, if you install a log target of the class [[\Yiisoft\Log\Target\File\FileTarget]],
@@ -205,11 +206,11 @@
 // (APP) [info] Text message
 ```
 
 In addition, if you're comfortable with the default message format but need to change the timestamp format
 or add custom data to the message, you can call the [[\Yiisoft\Log\Target::setTimestampFormat()|setTimestampFormat()]]
 and [[\Yiisoft\Log\Target::setPrefix()|setPrefix()]] methods. For example, the following code changes the timestamp
 format and configures a log target to prefix each log message with the current user ID
 (IP address and Session ID are removed for privacy reasons).
 
 ```php
 $fileTarget = new \Yiisoft\Log\Target\File\FileTarget('/path/to/app.log');
@@ -240,7 +241,7 @@
 You may adjust this behavior by calling target [[\Yiisoft\Log\Target::setCommonContext()|setCommonContext()]]
 method, passing an array of data in the `key => value` format that you want to include.
 For example, the following log target configuration specifies that only the
 value of the `$_SERVER` variable will be appended to the log messages.
 
 ```php
 $fileTarget = new \Yiisoft\Log\Target\File\FileTarget('/path/to/app.log');
@@ -248,7 +249,7 @@
 ```
 
 
 ### Message Trace Level <span id="trace-level"></span>
 
 During development, it's often desirable to see where each log message is coming from.
 You can achieve this by calling the [[\Yiisoft\Log\Logger::setTraceLevel()|setTraceLevel()]] method like the following:
@@ -258,8 +259,8 @@
 $logger->setTraceLevel(3);
 ```
 
 This application configuration sets the trace level to be 3, so each log message will be appended with at most three
 levels of the call stack at which the log message is recorded. You can also set a list of paths to exclude
 from the trace by calling the [[\Yiisoft\Log\Logger::setExcludedTracePaths()|setExcludedTracePaths()]] method.
 
 ```php
@@ -267,13 +268,14 @@
 $logger->setExcludedTracePaths(['/path/to/file', '/path/to/folder']);
 ```
 
-> Info: Getting call stack information isn't trivial. Therefore, you should only use this feature during development
+> [!IMPORTANT]
+> Getting call stack information isn't trivial. Therefore, you should only use this feature during development
 or when debugging an application.
 
 
 ### Message flushing and exporting <span id="flushing-exporting"></span>
 
 As aforementioned, log messages are maintained in an array by [[\Yiisoft\Log\Logger|logger object]]. To limit the
 memory consumption by this array, the logger will flush the recorded messages to the [log targets](#log-targets)
 each time the array accumulates a certain number of log messages. You can customize this number by calling
 the [[\Yiisoft\Log\Logger::setFlushInterval()]] method:
@@ -284,7 +286,8 @@
 $logger->setFlushInterval(100); // default is 1000
 ```
 
-> Info: Message flushing also occurs when the application ends,
+> [!IMPORTANT]
+> Message flushing also occurs when the application ends,
 which ensures log targets can receive complete log messages.
 
 When the [[\Yiisoft\Log\Logger|logger object]] flushes log messages to [log targets](#log-targets),
@@ -299,7 +302,7 @@
 ```
 
 Because of the flushing and exporting level setting, by default when you call any logging
 method, you will NOT see the log message immediately in the log targets. This could be a problem for some long-running
 console applications. To make each log message appear immediately in the log targets, you should set both
 flush interval and export interval to be 1, as shown below:
 
@@ -311,7 +314,8 @@
 $logger->setFlushInterval(1);
 ```
 
-> Note: Frequent message flushing and exporting will degrade the performance of your application.
+> [!NOTE]
+> Frequent message flushing and exporting will degrade the performance of your application.
 
 
 ### Toggling log targets <span id="toggling-log-targets"></span>
@@ -331,9 +335,9 @@
 }
 ```
 
 To check whether the log target is enabled, call the `isEnabled()` method.
 You also may pass callable to [[\Yiisoft\Log\Target::setEnabled()|setEnabled()]]
 to define a dynamic condition for whether the log target should be enabled or not.
 
 
 ### Creating new targets <span id="new-targets"></span>
@@ -350,7 +354,8 @@
 
 For more details, you may refer to any of the log target classes included in the package.
 
-> Tip: Instead of creating your own loggers, you may try any PSR-3 compatible logger such
+> [!TIP]
+> Instead of creating your own loggers, you may try any PSR-3 compatible logger such
 as [Monolog](https://github.com/Seldaek/monolog) by using [[\Yii\Log\PsrTarget]].
 
 ```php