SO has many articles mentioning this error code:

    FastCGI sent in stderr: &quot;Primary script unknown&quot; while reading response header from upstream...

That probably means that this error message is more or less useless.  

The message is telling us that the FastCGI handler doesn&#39;t like whatever it was sent for some reason.  The problem is that sometimes we have no idea what the reason is.

So I&#39;m re-stating the question -- How do we ***debug*** this error code?

Consider the situation where we have a very simple site, with just the phpinfo.php file.  Additionally, there is a very simple nginx config, as follows:

    server {
        server_name testsite.local;
    
    	root /var/local/mysite/;
     
        location / {
            index index.html index.htm index.php;
        }
     
        location ~ \.php$ {
            include /etc/nginx/fastcgi_params;
            fastcgi_pass  fastcgi_backend;
            fastcgi_index index.php;
            fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        }
    }

**How can we see output/log exactly what fastcgi_params got sent to the script?**

**How can we see the actual error message?**  In my case, I&#39;m using php-fpm.  It has no info in the log about this error.  The logs do not append any rows for this error.  Is there a verbose mode for php-fpm?

    /var/log/php-fpm/error.log
    /var/log/php-fpm/www-error.log

I&#39;ve tried to set this in the php-fpm.conf file

    log_level = notice

and this in the php-fpm.d/www.conf file:

    catch_workers_output = yes









How to debug &quot;FastCGI sent in stderr: Primary script unknown while reading response header from upstream&quot; and find the actual error message?

When printing the &quot;usage&quot; of an application, should it be done on stdout or on stderr?

Depending on the application I&#39;ve seen several cases, but there doesn&#39;t seem to be one rule. Maybe I&#39;m mistaken and there is one good practice. In that case, what is it?

Should the command line &quot;usage&quot; be printed on stdout or stderr?

I&#39;m learning the language from Programming Ruby 1.9, and they toss STDERR.puts into a block of code early in the book without explaining why they&#39;re using it or how it&#39;s different from puts.

I&#39;ve googled and wikied the term, but all I can gather from my research is that it&#39;s involved in diagnostics. Nowhere in the code provided by Programming Ruby does there seem to be a link to error exception handling. 

Here&#39;s the code. 

    require_relative &#39;csv_reader&#39;
    reader = CsvReader.new
    ARGV.each do |csv_file_name|
      STDERR.puts &quot;Processing #{csv_file_name}&quot;
      reader.read_in_csv_data(csv_file_name)
    end

I did manage to read somewhere that STDERR.puts is used for error handling out of convention, but I guess I&#39;m asking if it acts any differently than puts.


How is STDERR.puts different from puts in Ruby?

I&#39;m having trouble figuring out how to both echo to the standard error stream and redirect the error stream of an executable.

I have come from a [Bourne shell][1] and [Korn shell][2] background, of which I would use;

    # Write to stderr
    echo &quot;Error Message!&quot; &gt;&amp;2

    # Redirect stderr to file
    /do/error 2&gt;/tmp/err.msg

  [1]: https://en.wikipedia.org/wiki/Bourne_shell
  [2]: https://en.wikipedia.org/wiki/Korn_shell


How do I write to standard error in PowerShell?

I have a program that writes information to `stdout` and `stderr`, and I need to process the `stderr` with `grep`, leaving `stdout` aside.

Using a temporary file, one could do it in two steps:

    command &gt; /dev/null 2&gt; temp.file
    grep &#39;something&#39; temp.file

But how can this be achieved without temp files, using one command and pipes?

How can I pipe stderr, and not stdout?

I am rather confused with the purpose of these three files. If my understanding is correct, `stdin` is the file in which a program writes into its requests to run a task in the process, `stdout` is the file into which the kernel writes its output and the process requesting it accesses the information from, and `stderr` is the file into which all the exceptions are entered. On opening these files to check whether these actually do occur, I found nothing seem to suggest so!

What I would want to know is what exactly is the purpose of these files, absolutely dumbed down answer with very little tech jargon!


Confused about stdin, stdout and stderr?

Let&#39;s say I have a script like the following:

useless.sh

    echo &quot;This Is Error&quot; 1&gt;&amp;2
    echo &quot;This Is Output&quot; 

And I have another shell script:

alsoUseless.sh

    ./useless.sh | sed &#39;s/Output/Useless/&#39;

I want to capture &quot;This Is Error&quot;, or any other stderr from useless.sh, into a variable. 
Let&#39;s call it ERROR.

Notice that I am using stdout for something. I want to continue using stdout, so redirecting stderr into stdout is not helpful, in this case.

So, basically, I want to do

    ./useless.sh 2&gt; $ERROR | ...

but that obviously doesn&#39;t work.

I also know that I could do

    ./useless.sh 2&gt; /tmp/Error
    ERROR=`cat /tmp/Error`

but that&#39;s ugly and unnecessary.

Unfortunately, if no answers turn up here that&#39;s what I&#39;m going to have to do.

I&#39;m hoping there&#39;s another way.

Anyone have any better ideas?

How to store standard error in a variable

It seems that newer versions of bash have the `&amp;&gt;` operator, which (if I understand correctly), redirects both stdout and stderr to a file (`&amp;&gt;&gt;` appends to the file instead, as Adrian clarified). 

What&#39;s the simplest way to achieve the same thing, but instead piping to another command?

For example, in this line:

    cmd-doesnt-respect-difference-between-stdout-and-stderr | grep -i SomeError

I&#39;d like the grep to match on content both in stdout and stderr (effectively, have them combined into one stream).

*Note*: this question is asking about piping, *not* redirecting - so it is not a duplicate of the question it&#39;s currently marked as a duplicate of.

Piping both stdout and stderr in bash?

I want to redirect both [standard output][1] and [standard error][2] of a process to a single file. How do I do that in Bash?

  [1]: https://en.wikipedia.org/wiki/Standard_streams#Standard_output_.28stdout.29
  [2]: https://en.wikipedia.org/wiki/Standard_streams#Standard_error_(stderr)


Redirect stderr and stdout in Bash

In C, Printing to stdout is easy, with `printf` from `stdio.h`.

However, how can print to stderr? We can use `fprintf` to achieve it apparently, but its syntax seems strange. Maybe we can use `printf` to print to stderr?

How I can print to stderr in C?

It&#39;s well known how to pipe the standard ouput of a process into another processes standard input:

    proc1 | proc2

But what if I want to send the standard error of proc1 to proc2 and leave the standard output going to its current location? You would think `bash` would have a command along the lines of:

    proc1 2| proc2

But, alas, no. Is there any way to do this?


With bash, how can I pipe standard error into another process?

I have an application that logs a lot of noise to stderr and REALLY slows down the execution of the application. I would like to redirect that output to null. Is this possible with cmd.exe?


How to redirect stderr to null in cmd.exe

I want to get the `stdout` in a variable after running the `os.system` call.

Lets take this line as an example: 

    batcmd=&quot;dir&quot;
    result = os.system(batcmd)

`result` will contain the error code (`stderr` `0` under Windows or `1` under some linux for the above example).

How can I get the `stdout` for the above command without using redirection in the executed command?      


Python: How to get stdout after running os.system?

Reading the man pages and some code did not really help me in 
understanding the difference between - or better, when I should use - `perror(&quot;...&quot;)` or `fprintf(stderr, &quot;...&quot;)`.

When should I use perror(&quot;...&quot;) and fprintf(stderr, &quot;...&quot;)?

I am trying to redirect all output from a command line programme to a file.  I am using Bash.  Some of the output is directed to a the file, but some still appears in the terminal and is not stored to the file.  

Similar symptoms are described here:

https://stackoverflow.com/questions/6674327/redirect-all-output-to-file

However I have tried the proposed solution (capture stderr) without success:

    &lt;cmd&gt; &lt;args&gt; &gt; stdout.txt 2&gt; stderr.txt

The file stderr.txt is created but is empty.

A possible clue is that the command-line programme is a client communicating with a server on the same machine.  It may be that some of the output is coming from the **server**.  

Is there a way to capture all the output from the terminal, irrespective of its origin?

**EDIT:**

I&#39;ve confirmed that the missing output is generated by the server.  Running the command in a separate terminal causes some output in both terminals, I can pipe all the output from the command terminal to a file.  This raises issues about how to capture the server output, but that&#39;s a different question.


Redirect all output to file using Bash on Linux?

In Ruby, what is the difference between `$stdout` (preceded by a dollar sign) and `STDOUT` (in all caps)? When doing output redirection, which should be used and why? The same goes for `$stderr` and `STDERR`.

**Edit:** Just found a [related question](https://stackoverflow.com/questions/4279604/what-is-the-difference-between-stdin-and-stdin-in-ruby).

Difference between $stdout and STDOUT in Ruby

To redirect [standard output][1] to a truncated file in Bash, I know to use:

    cmd &gt; file.txt

To redirect standard output in Bash, appending to a file, I know to use:

    cmd &gt;&gt; file.txt

To redirect both standard output and [standard error][2] to a truncated file, I know to use:

    cmd &amp;&gt; file.txt

How do I redirect both standard output and standard error appending to a file? `cmd &amp;&gt;&gt; file.txt` did not work for me.


  [1]: https://en.wikipedia.org/wiki/Standard_streams#Standard_output_.28stdout.29
  [2]: https://en.wikipedia.org/wiki/Standard_streams#Standard_error_(stderr)



How to redirect and append both standard output and standard error to a file with Bash

I&#39;m looking for a Python solution that will allow me to save the output of a command in a file without hiding it from the console.

FYI: I&#39;m asking about [tee][1] (as the Unix command line utility) and not the function with the same name from Python intertools module.

### Details ###

* Python solution (not calling `tee`, it is not available under Windows)
* I do not need to provide any input to stdin for called process
* I have no control over the called program. All I know is that it will output something to stdout and stderr and return with an exit code.
* To work when calling external programs (subprocess)
* To work for both `stderr` and `stdout`
* Being able to differentiate between stdout and stderr because I may want to display only one of the to the console or I could try to output stderr using a different color - this means that `stderr = subprocess.STDOUT` will not work.
* Live output (progressive) - the process can run for a long time, and I&#39;m not able to wait for it to finish.
* Python 3 compatible code (important)

### References ###

Here are some incomplete solutions I found so far:

* http://devlishgenius.blogspot.com/2008/10/logging-in-real-time-in-python.html (mkfifo works only on Unix)
* http://blog.kagesenshi.org/2008/02/teeing-python-subprocesspopen-output.html (doesn&#39;t work at all)

![Diagram][2]

### Current code (second try) ###

    #!/usr/bin/python
    from __future__ import print_function

    import sys, os, time, subprocess, io, threading
    cmd = &quot;python -E test_output.py&quot;

    from threading import Thread
    class StreamThread ( Thread ):
    	def __init__(self, buffer):
    		Thread.__init__(self)
    		self.buffer = buffer
    	def run ( self ):
    		while 1:
    			line = self.buffer.readline()
    			print(line,end=&quot;&quot;)
    			sys.stdout.flush()
    			if line == &#39;&#39;:
    				break

    proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    stdoutThread = StreamThread(io.TextIOWrapper(proc.stdout))
    stderrThread = StreamThread(io.TextIOWrapper(proc.stderr))
    stdoutThread.start()
    stderrThread.start()
    proc.communicate()
    stdoutThread.join()
    stderrThread.join()

    print(&quot;--done--&quot;)

    #### test_output.py ####

    #!/usr/bin/python
    from __future__ import print_function
    import sys, os, time

    for i in range(0, 10):
    	if i%2:
    		print(&quot;stderr %s&quot; % i, file=sys.stderr)
    	else:
    		print(&quot;stdout %s&quot; % i, file=sys.stdout)
    	time.sleep(0.1)


#### Real output ####

    stderr 1
    stdout 0
    stderr 3
    stdout 2
    stderr 5
    stdout 4
    stderr 7
    stdout 6
    stderr 9
    stdout 8
    --done--

Expected output was to have the lines ordered. Remark, modifying the Popen to use only one PIPE is not allowed because in the real life I will want to do different things with stderr and stdout.

Also even in the second case I was not able to obtain real-time like out, in fact all the results were received when the process finished. By default, Popen should use no buffers (bufsize=0).

  [1]: https://en.wikipedia.org/wiki/Tee_%28command%29
  [2]: http://blog.i18n.ro/wp-content/uploads/2010/06/Drawing_tee_py.png


How to replicate tee behavior in Python when using subprocess?

There are several ways to write to stderr:

    # Note: this first one does not work in Python 3
    print &gt;&gt; sys.stderr, &quot;spam&quot;

    sys.stderr.write(&quot;spam\n&quot;)

    os.write(2, b&quot;spam\n&quot;)

    from __future__ import print_function
    print(&quot;spam&quot;, file=sys.stderr)

That seems to contradict *zen of Python #13* &lt;sup&gt;†&lt;/sup&gt;, so what&#39;s the difference here and are there any advantages or disadvantages to one way or the other? Which way should be used?

&lt;sup&gt;†&lt;/sup&gt; &lt;sub&gt;There should be one — and preferably only one — obvious way to do it.&lt;/sub&gt;


How to print to stderr in Python?

Is it possible to temporarily redirect stdout/stderr in Python (i.e. for the duration of a method)?

### Edit:

The problem with the current solutions (which I at first remembered but then forgot) is that they don&#39;t *redirect*; rather, they just replace the streams in their entirety. Hence, if a method has a ***local* copy** of one the variable for any reason (e.g. because the stream was passed as a parameter to something), it won&#39;t work.

Any solutions?

Temporarily Redirect stdout/stderr

there has been many previous questions about redirecting  stdout/stderr to a file. is there a way to redirect  stdout/stderr to a string?

redirect stdout/stderr to a string

I&#39;m writing a script to backup a database. I have the following line:

    mysqldump --user=$dbuser --password=$dbpswd  \
       --host=$host $mysqldb | gzip &gt; $filename

I want to assign the stderr to a variable, so that it will send an email to myself letting me know what happened if something goes wrong. I&#39;ve found solutions to redirect stderr to stdout, but I can&#39;t do that as the stdout is already being sent (via gzip) to a file. How can I separately store stderr in a variable $result ?



Bash script - store stderr in a variable

Is it possible to capture the stdout and stderr when using the [googletest][1] framework?

For example, I would like to call a function that writes errors to the console (stderr).
Now, when calling the function in the tests, I want to assert that no output appears there.

Or, maybe I want to test the error behaviour and want to assert that a certain string gets printed when I (deliberately) produce an error.


  [1]: http://code.google.com/p/googletest/

How to capture stdout/stderr with googletest?

(Gradle 3.2.1) I run some java tests, which logs output in Stderr/Stdout. I can see that output, if I start

    gradle test --info

but in that case, much of unwanted output from 3-rd party libraries is there too.

[Documentation][1] suggests using ```logging.caputureStandardError / logging.caputureStandardError (loglevel)```, but it doesn&#39;t seem to have any effect.

    tasks.withType(Test) {
       logging.captureStandardOutput LogLevel.QUIET
       logging.captureStandardError LogLevel.QUIET
    }

Then if running ```gradle test```, not STDERR/STDOUT is output in console.

How can I get just the output from the tests classes in console?


  [1]: https://docs.gradle.org/current/userguide/logging.html#sec:external_tools

Gradle: How to get output from test STDERR/STDOUT into console?

I am running a bash script that creates a log file for the execution of the command

I use the following

    Command1 &gt;&gt; log_file
    Command2 &gt;&gt; log_file

This only sends the standard output and not the standard error which appears on the terminal.




How to redirect both stdout and stderr to a file

How do you print to `stderr` in `R`?

This would especially useful for scripts written in `Rscript`.

How do you print to stderr in R?

In PHP I am executing a command with exec(), and it returns if successful an URL;

    $url = exec(&#39;report&#39;);

However, I want to check stderr, if something went wrong. How would I read the stream?
I want to use php://stderr, but I am not sure how to use it.

PHP StdErr after Exec()

I want to split `stdout` so that it is printed both to `stdout` and `stderr`.  This sounds like a job for `tee` but the syntax is evading me -

    ./script.sh | tee stderr

Of course, how should `stderr` actually be referred to here?

How to tee to stderr?

Bash how do you capture stderr to a variable?

I would like to do something like this inside of my bash script

    sh -c path/myExcecutable-bin 2&gt;&amp;1 =MYVARIABLE


How do you send stderror output to a variable ?


Bash how do you capture stderr to a variable?

I know this syntax

    var=`myscript.sh`
or

    var=$(myscript.sh)

Will capture the result (`stdout`) of `myscript.sh` into `var`. I could redirect `stderr` into `stdout` if I wanted to capture both.  How to save each of them to separate variables?

My use case here is if the return code is nonzero I want to echo `stderr` and suppress otherwise.  There may be other ways to do this but this approach seems it will work, if it&#39;s actually possible.

All Stderr Solutions on Gang of Coders

Total of 30 Stderr Solutions

How to debug "FastCGI sent in stderr: Primary script unknown while reading response header from upstream" and find the actual error message?

Should the command line "usage" be printed on stdout or stderr?