showing message("The message") in the terminal when running quarto

[rkrug]

Description

I am using quarto 1.3.450 with R on an M1 iMac (and MacBook Pro) and run

quarto preview "document.qmd" --no-browser --no-watch-inputs

to render a report. But nobody is perfect, and some code chunks have errors, particularly in e.g. lapply(). I now included message() in the FUN argument, and I see the messages when I execute the code block in R, but when I render the whole document, I do not see the messages. This has also been asked at stackoverflow.

The question is: how can I see the output from e.g. message() in a code chunk when running quarto from the terminal?

I do not want to see them in the rendered Report itself (and the rendering should fail when an error occurs), but only in the terminal from where I run quarto ....

[mcanouil]

Could you share a small self-contained "working" (reproducible) example to work with, i.e., a complete Quarto document or a Git repository? Thanks.

See the troubleshooting guide: https://quarto.org/docs/troubleshooting/index.html

You can share a Quarto document using the following syntax, i.e., using more backticks than you have in your document (usually four ````).

````qmd
---
title: "Reproducible Quarto Document"
format: html
---

This is a reproducible Quarto document using `format: html`.
It is written in Markdown and contains embedded R code.
When you run the code, it will produce a plot.

```{r}
plot(cars)
```

The end.
````

[rkrug]

Sorry - here it is:

---
title: "Reproducible Quarto Document"
format: html
---

This is a reproducible Quarto document using `format: html`.
It is written in Markdown and contains embedded R code.
When you run the code, it will produce a plot.

```{r}
message("I want to see this")

stop("And stop!")
```

The end.
```

And the output in the terminal is:

10:46 $ quarto preview ~/temp/Untitled-1.qmd


processing file: Untitled-1.qmd
1/3
2/3 [unnamed-chunk-1]

Quitting from lines 11-13 [unnamed-chunk-1] (Untitled-1.qmd)
Error:
! And stop!
Execution halted

And I do not see the message "I want to see this"

Hope this helps.

[mcanouil]

Note that this is unrelated to Quarto, as it is knitr behaviour.
Same thing would happen when using rmarkdown.

@cderv will know of a/the way to do that (i.e., redirects messages to console) if it exists.

[cderv]

I believe this is related to a change in knitr 1.42: https://github.com/yihui/knitr/blob/master/NEWS.md#changes-in-knitr-version-142

Due to a change in the evaluate package, the chunk options message = FALSE and warning = FALSE will completely suppress the messages/warnings now, instead of sending them to the console. To get back to the old behavior, you can use NA instead of FALSE

There is a blog post about it: https://yihui.org/en/2022/12/message-false/

It was part of the progress bar improvement

If you want the old behavior, you can use message = NA to get it back.

---
title: "Reproducible Quarto Document"
format: html
---

This is a reproducible Quarto document using `format: html`.
It is written in Markdown and contains embedded R code.
When you run the code, it will produce a plot.

```{r, message = NA}
message("I want to see this")

# stop("And stop!")
```

The end
```

If you are used to logging from your code, I would consider logging package too like logger

---
title: "Reproducible Quarto Document"
format: html
---

This is a reproducible Quarto document using `format: html`.
It is written in Markdown and contains embedded R code.
When you run the code, it will produce a plot.

```{r}
library(logger)
```


```{r}
log_info("This is from logger")
```

The end

You can send to a file like any program log file.

```{r}
library(logger)
log_appender(appender_file("knit.log"))
```

Hope it helps understand.

[rkrug]

Thanks - works. I tried to set message in the yaml front matter, but it did not work:

---
title: "Reproducible Quarto Document"
format: html
execute: 
  message: NA
---

or

---
title: "Reproducible Quarto Document"
format: html
execute: 
  message: "NA"
---

did not work.

[mcanouil]

This is because NA is an R thing that does not exist in YAML, i.e., here with or without quotes does not change anything as in YAML it means a string, but for R "NA" is not NA.

Here you would need to make something not the Quarto way unfortunately because of the above:

knitr::opts_chunk$set(message = NA)

Note that even in plain knitr/rmarkdown, eventhough YAML is supported by knitr natively, the following is still "invalid":

```{r}
#| message: NA
message("something")
```

Valid:

```{r, message = NA}
message("something")
```

```{r}
#| message = NA
message("something")
```

[rkrug]

Hm. OK. I will use knitr::opts_chunk$set(message = NA) in this c case and look into logging packages.

Thanks.

[jarodmeng]

It seems that the quarto cell config option doesn't work anymore.

i.e. The following code returns error when rendering.

#| message = NA
message("something")

Put the config in the {r} block still works.

[jarodmeng]

Sorry for the confusion. I wasn't able to escape the code block so it was rendered rather than printed.

when message = NA is included in the {r} label, it works.

# This method works
```{r, message = NA}
message("something")
```

However, when it's included as a quarto label within the block, it doesn't work.

# This doesn't work
```{r}
#| message = NA
message("something")
```

[cderv]

# This doesn't work
```{r}
#| message = NA
message("something")
```

This ☝️ is a valid knitr syntax, and it works for - I cannot see the message in the doc, but can see it in the console log.
It is made available since knitr 1.42 as option for backward compatibility when needed.

Though, I wouldn't use it in Quarto. I know it has been suggested above but only the YAML syntax should really be preferred.
NA is an R object and doesn't have a YAML equivalent, so for this you will need a specific R-only trick, which is to use !expr yaml tag

```{r}
#| message: !expr NA
message("something")
```

The doc (https://quarto.org/docs/computations/r.html#chunk-options) does not mention this specific case but

• shows that options are YAML
• mentions the !expr for R values in options.

Hope it helps understand.

Regarding the need to use message = NA, I don't known your context, but if this is for logging purpose, see my answer above #7443 (reply in thread)

[isaactpetersen]

I have the same issue as the original poster. I receive an error when using the following syntax:

```{r}
#| message: !expr NA
message("something")
```

Here's the error in GitHub Actions:

[ 1/29] index.qmd
ERROR: Validation of YAML cell metadata failed.
ERROR: In file index.qmd
(line 5, columns 13--21) Field "message" has value !expr NA, which must instead be one of: `true`, `false`, `NA`
4: #| include: false
5: #| message: !expr NA
              ~~~~~~~~~

However, the following works for me:

knitr::opts_chunk$set(message = NA)

[mcanouil]

@isaactpetersen Please avoid posting on old thread (open a new one referencing it as old thread usually contains outdated informations), especially if you don't specify the Quarto CLI version being used.

You are either not using the latest version of knitr and/or the latest stable version of Quarto CLI (1.7.32).

Edit: actually you are using the correct version as it is stated in the error message that message expects "NA" not "!expr NA". Field "message" has value !expr NA, which must instead be one of: `true`, `false`, `NA`

Note that the use of !expr is discouraged in most cases in Quarto CLI.

---
format: html
---

```{r}
#| message: NA

message("This is a test message.")
```

And if you want to set message: NA globally:

---
format: html
knitr:
  opts_chunk:
    message: NA
---

```{r}
message("This is a test message.")
```

[isaactpetersen]

I opened a new discussion here: #13040