Remove instances of $ from commands that don't include output

administration/monitoring.md

@@ -71,10 +71,10 @@ Start Fluent bit with the corresponding configuration chosen above:
 
 ```shell
 # For YAML configuration.
-$ ./bin/fluent-bit --config fluent-bit.yaml
+./bin/fluent-bit --config fluent-bit.yaml
 
 # For classic configuration.
-$ ./bin/fluent-bit --config fluent-bit.conf
+./bin/fluent-bit --config fluent-bit.conf
 ```
 
 Fluent Bit starts and generates output in your terminal:
@@ -282,7 +282,7 @@ The command prints a similar output like this:
 Query internal metrics in JSON format with the following command:
 
 ```shell
-$ curl -s http://127.0.0.1:2020/api/v1/metrics | jq
+curl -s http://127.0.0.1:2020/api/v1/metrics | jq
 ```
 
 The command prints a similar output like this:
@@ -312,7 +312,7 @@ The command prints a similar output like this:
 Query internal metrics in Prometheus Text 0.0.4 format:
 
 ```shell
-$ curl -s http://127.0.0.1:2020/api/v1/metrics/prometheus
+curl -s http://127.0.0.1:2020/api/v1/metrics/prometheus
 ```
 
 This command returns the same metrics in Prometheus format instead of JSON:
@@ -506,7 +506,7 @@ pipeline:
 Use the following command to call the health endpoint:
 
 ```shell
-$ curl -s http://127.0.0.1:2020/api/v1/health
+curl -s http://127.0.0.1:2020/api/v1/health
 ```
 
 With the example configuration, the health status is determined by the following equation:

development/msgpack-format.md

@@ -16,7 +16,7 @@ This section provides an overview of the specific types used by Fluent Bit withi
 Set up Fluent Bit to send in `msgpack` format to a specific port.
 
 ```bash
-$ docker run --rm -it --network=host fluent/fluent-bit /fluent-bit/bin/fluent-bit -i cpu -o tcp://127.0.0.1:5170 -p format=msgpack -v
+docker run --rm -it --network=host fluent/fluent-bit /fluent-bit/bin/fluent-bit -i cpu -o tcp://127.0.0.1:5170 -p format=msgpack -v
 
 ```
 

development/wasm-filter-plugins.md

@@ -35,9 +35,9 @@ Currently, Fluent Bit supports the following Wasm tool chains:
 As described in the general options in the [source installation](../installation/sources/build-and-install.md) guide, Wasm support is enabled by default. Compile Fluent Bit with Wasm support, for example:
 
 ```text
-$ cd build/
-$ cmake .. [-DFLB_WAMRC=On]
-$ make
+cd build/
+cmake .. [-DFLB_WAMRC=On]
+make
 ```
 
 To support AOT-compiled Wasm execution as filter plugins, build Fluent Bit with `-DFLB_WAMRC=On`.
@@ -65,7 +65,7 @@ The Fluent Bit Wasm filter assumes C ABI, also known as `wasm32-unknown-unknown`
 TinyGo and WASI SDK support Wasm target by default. When using Rust's `wasm32-unknown-unknown` target, you must install `wasm32-unknown-unknown` by using [rustup](https://rustup.rs/). Then, install the target components as follows:
 
 ```text
-$ rustup target add wasm32-unknown-unknown
+rustup target add wasm32-unknown-unknown
 ```
 
 ### Requirements of Wasm programs
@@ -228,13 +228,13 @@ To optimize Wasm program execution, there is the option of using `flb-wamrc`. Th
 This tool will be built when the `-DFLB_WAMRC=On` CMake option is specified and LLVM infrastructure is installed on the building box.
 
 ```shell
-$ flb-wamrc -o /path/to/built_wasm.aot /path/to/built_wasm.wasm
+flb-wamrc -o /path/to/built_wasm.aot /path/to/built_wasm.wasm
 ```
 
 For further optimizations to the specific CPU, such as Cortex-A57 series:
 
 ```text
-$ flb-wamrc --size-level=3 --target=aarch64v8 --cpu=cortex-a57 -o /path/to/built_wasm.aot /path/to/built_wasm.wasm
+flb-wamrc --size-level=3 --target=aarch64v8 --cpu=cortex-a57 -o /path/to/built_wasm.aot /path/to/built_wasm.wasm
 ```
 
 Then, when AOT (Ahead Of Time) compiling has succeeded:

development/wasm-input-plugins.md

@@ -25,9 +25,9 @@ Fluent Bit supports the following Wasm toolchains:
 Compile Fluent Bit with Wasm support. For example:
 
 ```text
-$ cd build/
-$ cmake ..
-$ make
+cd build/
+cmake ..
+make
 ```
 
 Once compiled, you can see new plugins that handle `wasm`. For example:
@@ -53,7 +53,7 @@ Wasm input in Fluent Bit assumes WASI ABI, also known as `wasm32-wasi` on Rust t
 TinyGo and WASI SDK support Wasm target by default. When using Rust's `wasm32-wasi` target, you must install `wasm32-wasi` by using [rustup](https://rustup.rs/). Then, install the target components as:
 
 ```text
-$ rustup target add wasm32-wasi
+rustup target add wasm32-wasi
 ```
 
 ### Requirements of Wasm/WASI programs

pipeline/filters/aws-metadata.md

@@ -29,7 +29,7 @@ If you run Fluent Bit in a container, you might need to use instance metadata v1
 Run Fluent Bit from the command line:
 
 ```shell
-$ ./fluent-bit -c /PATH_TO_CONF_FILE/fluent-bit.conf
+./fluent-bit -c /PATH_TO_CONF_FILE/fluent-bit.conf
 ```
 
 You should see results like this:

pipeline/filters/grep.md

@@ -42,7 +42,7 @@ When using the command line, pay close attention to quote the regular expression
 The following command loads the [tail](../../pipeline/inputs/tail) plugin and reads the content of `lines.txt`. Then the `grep` filter applies a regular expression rule over the `log` field created by the `tail` plugin and only passes records with a field value starting with `aa`:
 
 ```shell
-$ ./fluent-bit -i tail -p 'path=lines.txt' -F grep -p 'regex=log aa' -m '*' -o stdout
+./fluent-bit -i tail -p 'path=lines.txt' -F grep -p 'regex=log aa' -m '*' -o stdout
 ```
 
 ### Configuration file

pipeline/filters/lua.md

@@ -31,7 +31,7 @@ To test the Lua filter, you can run the plugin from the command line or through
 From the command line you can use the following options:
 
 ```shell
-$ ./fluent-bit -i dummy -F lua -p script=test.lua -p call=cb_print -m '*' -o null
+./fluent-bit -i dummy -F lua -p script=test.lua -p call=cb_print -m '*' -o null
 ```
 
 ### Configuration file

pipeline/filters/modify.md

@@ -95,7 +95,7 @@ which outputs data similar to the following:
 Using the command line mode requires quotes parse the wildcard properly. The use of a configuration file is recommended.
 
 ```shell
-$ ./fluent-bit -i mem \
+./fluent-bit -i mem \
               -p 'tag=mem.local' \
               -F modify \
               -p 'Add=Service1 SOMEVALUE' \

pipeline/filters/multiline-stacktrace.md

@@ -246,7 +246,7 @@ one more line, no multiline
 Running Fluent Bit with the given configuration file:
 
 ```shell
-$ ./fluent-bit -c fluent-bit.conf
+./fluent-bit -c fluent-bit.conf
 ```
 
 Should return something like the following:

pipeline/filters/nest.md

@@ -91,7 +91,7 @@ wildcard rule to the keys and nests the keys matching `Mem.*` under the new key
 `NEST`.
 
 ```shell
-$ ./fluent-bit -i mem -p 'tag=mem.local' -F nest -p 'Operation=nest' -p 'Wildcard=Mem.*' -p 'Nest_under=Memstats' -p 'Remove_prefix=Mem.' -m '*' -o stdout
+./fluent-bit -i mem -p 'tag=mem.local' -F nest -p 'Operation=nest' -p 'Wildcard=Mem.*' -p 'Nest_under=Memstats' -p 'Remove_prefix=Mem.' -m '*' -o stdout
 ```
 
 ### Nest configuration file

pipeline/filters/nightfall.md

@@ -81,10 +81,10 @@ After you configure the filter, you can use it from the command line by running
 
 ```shell
 # For YAML configuration.
-$ ./fluent-bit -c /PATH_TO_CONF_FILE/fluent-bit.yaml
+./fluent-bit -c /PATH_TO_CONF_FILE/fluent-bit.yaml
 
 # For classic configuration.
-$ ./fluent-bit -c /PATH_TO_CONF_FILE/fluent-bit.conf
+./fluent-bit -c /PATH_TO_CONF_FILE/fluent-bit.conf
 ```
 
 Replace _`PATH_TO_CONF_FILE`_ with the path for where your filter configuration file

pipeline/filters/record-modifier.md

@@ -76,7 +76,7 @@ pipeline:
 You can run the filter from command line:
 
 ```shell
-$ ./fluent-bit -i mem -o stdout -F record_modifier -p 'Record=hostname ${HOSTNAME}' -p 'Record=product Awesome_Tool' -m '*'
+./fluent-bit -i mem -o stdout -F record_modifier -p 'Record=hostname ${HOSTNAME}' -p 'Record=product Awesome_Tool' -m '*'
 ```
 
 The output looks something like:
@@ -137,7 +137,7 @@ pipeline:
 You can also run the filter from command line.
 
 ```shell
-$ ./fluent-bit -i mem -o stdout -F  record_modifier -p 'Remove_key=Swap.total' -p 'Remove_key=Swap.free' -p 'Remove_key=Swap.used' -m '*'
+./fluent-bit -i mem -o stdout -F  record_modifier -p 'Remove_key=Swap.total' -p 'Remove_key=Swap.free' -p 'Remove_key=Swap.used' -m '*'
 ```
 
 The output looks something like:
@@ -198,7 +198,7 @@ pipeline:
 You can also run the filter from command line:
 
 ```shell
-$ ./fluent-bit -i mem -o stdout -F record_modifier -p 'Allowlist_key=Mem.total' -p 'Allowlist_key=Mem.free' -p 'Allowlist_key=Mem.used' -m '*'
+./fluent-bit -i mem -o stdout -F record_modifier -p 'Allowlist_key=Mem.total' -p 'Allowlist_key=Mem.free' -p 'Allowlist_key=Mem.used' -m '*'
 ```
 
 The output looks something like:

pipeline/filters/rewrite-tag.md

@@ -209,7 +209,7 @@ The `rewrite_tag` filter emits new records that go through the beginning of the
 Using the previously provided configuration, when you query the metrics exposed in the HTTP interface:
 
 ```shell
-$ ./curl  http://127.0.0.1:2020/api/v1/metrics/ | jq
+./curl  http://127.0.0.1:2020/api/v1/metrics/ | jq
 ```
 
 You will see metrics output similar to the following:

pipeline/filters/tensorflow.md

@@ -29,7 +29,7 @@ To create a Tensorflow Lite shared library:
 1. Run the following command to create the shared library:
 
    ```shell
-   $ ./bazel build -c opt //tensorflow/lite/c:tensorflowlite_c  # see https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite/c
+   ./bazel build -c opt //tensorflow/lite/c:tensorflowlite_c  # see https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite/c
    ```
 
    The script creates the shared library
@@ -41,7 +41,7 @@ To create a Tensorflow Lite shared library:
 The Tensorflow filter plugin is disabled by default. You must build Fluent Bit with the Tensorflow plugin enabled. In addition, it requires access to Tensorflow Lite header files to compile. Therefore, you must pass the address of the Tensorflow source code on your machine to the [build script](https://github.com/fluent/fluent-bit#build-from-scratch):
 
 ```shell
-$ ./cmake -DFLB_FILTER_TENSORFLOW=On -DTensorflow_DIR=<AddressOfTensorflowSourceCode> ...
+./cmake -DFLB_FILTER_TENSORFLOW=On -DTensorflow_DIR=<AddressOfTensorflowSourceCode> ...
 ```
 
 ### Command line
@@ -51,7 +51,7 @@ If the Tensorflow plugin initializes correctly, it reports successful creation o
 The command:
 
 ```shell
-$ ./fluent-bit -i mqtt -p 'tag=mqtt.data' -F tensorflow -m '*' -p 'input_field=image' -p 'model_file=/home/user/model.tflite' -p
+./fluent-bit -i mqtt -p 'tag=mqtt.data' -F tensorflow -m '*' -p 'input_field=image' -p 'model_file=/home/user/model.tflite' -p
 ```
 
 produces an output like:

pipeline/filters/throttle.md

@@ -112,7 +112,7 @@ It's suggested to use a configuration file.
 The following command will load the Tail plugin and read the content of the `lines.txt` file. Then, the Throttle filter will apply a rate limit and only pass the records which are read below the `rate`:
 
 ```shell
-$ ./fluent-bit -i tail -p 'path=lines.txt' -F throttle -p 'rate=1' -m '*' -o stdout
+./fluent-bit -i tail -p 'path=lines.txt' -F throttle -p 'rate=1' -m '*' -o stdout
 ```
 
 ### Configuration File

pipeline/filters/type-converter.md

@@ -83,7 +83,7 @@ pipeline:
 You can also run the filter from command line.
 
 ```shell
-$ ./fluent-bit -i mem -o stdout -F type_converter -p 'uint_key=Mem.total Mem.total_str string' -p 'uint_key=Mem.used Mem.used_str string' -p 'uint_key=Mem.free Mem.free_str string' -m '*'
+./fluent-bit -i mem -o stdout -F type_converter -p 'uint_key=Mem.total Mem.total_str string' -p 'uint_key=Mem.used Mem.used_str string' -p 'uint_key=Mem.free Mem.free_str string' -m '*'
 ```
 
 The output will be

pipeline/inputs/cpu-metrics.md

@@ -40,7 +40,7 @@ In order to get the statistics of the CPU usage of your system, you can run the
 You can run this filter from the command line using a command like the following:
 
 ```shell
-$ build/bin/fluent-bit -i cpu -t my_cpu -o stdout -m '*'
+build/bin/fluent-bit -i cpu -t my_cpu -o stdout -m '*'
 ```
 
 The command returns results similar to the following:

pipeline/inputs/disk-io-metrics.md

@@ -24,7 +24,7 @@ In order to get disk usage from your system, you can run the plugin from the com
 You can run the plugin from the command line:
 
 ```shell
-$ fluent-bit -i disk -o stdout
+fluent-bit -i disk -o stdout
 ```
 
 Which returns information like the following:

pipeline/inputs/docker-events.md

@@ -21,7 +21,7 @@ This plugin supports the following configuration parameters:
 You can run this plugin from the command line:
 
 ```shell
-$ fluent-bit -i docker_events -o stdout
+fluent-bit -i docker_events -o stdout
 ```
 
 ### Configuration file

pipeline/inputs/dummy.md

@@ -29,7 +29,7 @@ You can run the plugin from the command line or through the configuration file:
 Run the plugin from the command line using the following command:
 
 ```shell
-$ fluent-bit -i dummy -o stdout
+fluent-bit -i dummy -o stdout
 ```
 
 which returns results like the following:

pipeline/inputs/ebpf.md

@@ -58,10 +58,10 @@ To enable the `in_ebpf` plugin, follow these steps to build Fluent Bit from sour
 
    ```bash
    # For YAML configuration.
-   $ sudo ./bin/fluent-bit --config fluent-bit.yaml
+   sudo ./bin/fluent-bit --config fluent-bit.yaml
 
    # For classic configuration.
-   $ sudo ./bin/fluent-bit --config fluent-bit.conf
+   sudo ./bin/fluent-bit --config fluent-bit.conf
    ```
 
 ## Configuration example

pipeline/inputs/elasticsearch.md

@@ -29,7 +29,7 @@ In order to start performing the checks, you can run the plugin from the command
 From the command line you can configure Fluent Bit to handle Bulk API requests with the following options:
 
 ```shell
-$ fluent-bit -i elasticsearch -p port=9200 -o stdout
+fluent-bit -i elasticsearch -p port=9200 -o stdout
 ```
 
 ### Configuration file

pipeline/inputs/exec.md

@@ -39,7 +39,7 @@ You can run the plugin from the command line or through the configuration file:
 The following example will read events from the output of _ls_.
 
 ```shell
-$ fluent-bit -i exec -p 'command=ls /var/log' -o stdout
+fluent-bit -i exec -p 'command=ls /var/log' -o stdout
 ```
 
 which should return something like the following:

pipeline/inputs/fluentbit-metrics.md

@@ -83,5 +83,5 @@ pipeline:
 You can test the expose of the metrics by using `curl`:
 
 ```shell
-$ curl http://127.0.0.1:2021/metrics
+curl http://127.0.0.1:2021/metrics
 ```

pipeline/inputs/forward.md

@@ -32,13 +32,13 @@ To receive Forward messages, you can run the plugin from the command line or thr
 From the command line you can let Fluent Bit listen for Forward messages with the following options:
 
 ```shell
-$ fluent-bit -i forward -o stdout
+fluent-bit -i forward -o stdout
 ```
 
 By default, the service listens on all interfaces (`0.0.0.0`) through TCP port `24224`. You can change this by passing parameters to the command:
 
 ```shell
-$ fluent-bit -i forward -p listen="192.168.3.2" -p port=9090 -o stdout
+fluent-bit -i forward -p listen="192.168.3.2" -p port=9090 -o stdout
 ```
 
 In the example, the Forward messages arrive only through network interface `192.168.3.2` address and TCP Port `9090`.
@@ -138,13 +138,13 @@ pipeline:
 After Fluent Bit is running, you can send some messages using the `fluent-cat` tool, provided by [Fluentd](http://www.fluentd.org):
 
 ```shell
-$ echo '{"key 1": 123456789, "key 2": "abcdefg"}' | fluent-cat my_tag
+echo '{"key 1": 123456789, "key 2": "abcdefg"}' | fluent-cat my_tag
 ```
 
 When you run the plugin with the following command:
 
 ```shell
-$ fluent-bit -i forward -o stdout
+fluent-bit -i forward -o stdout
 ```
 
 In [Fluent Bit](http://fluentbit.io) you should see the following output:

pipeline/inputs/head.md

@@ -90,7 +90,7 @@ pipeline:
 If you run the following command:
 
 ```shell
-$ fluent-bit -c head.conf
+fluent-bit -c head.conf
 ```
 
 The output is something similar to;
@@ -118,7 +118,7 @@ To read the head of a file, you can run the plugin from the command line or thro
 The following example will read events from the `/proc/uptime` file, tag the records with the `uptime` name and flush them back to the `stdout` plugin:
 
 ```shell
-$ fluent-bit -i head -t uptime -p File=/proc/uptime -o stdout -m '*'
+fluent-bit -i head -t uptime -p File=/proc/uptime -o stdout -m '*'
 ```
 
 The output will look similar to:

pipeline/inputs/health.md

@@ -26,7 +26,7 @@ To start performing the checks, you can run the plugin from the command line or
 From the command line you can let Fluent Bit generate the checks with the following options:
 
 ```shell
-$ fluent-bit -i health -p host=127.0.0.1 -p port=80 -o stdout
+fluent-bit -i health -p host=127.0.0.1 -p port=80 -o stdout
 ```
 
 ### Configuration file