How to write out or trace specific commands in a PowerShell script?

There is no built-in feature I'm aware of that echoes a version of a command being executed with variables and expressions used in arguments expanded.

Even if there were, it would only work faithfully in simple cases, because not all objects have literal representations.

However, with limitations, you can roll your own solution, based on &, the call operator, and parameter splatting via a hashtable of argument values defined up front:

# Sample argument values.
$rgFullName = 'full name'
$location = 'loc'
$tags = @{ one = 1; two = 2; three = 3 }

# Define the command to execute:
#   * as a string variable that contains the command name / path
#   * as a hashtable that defines the arguments to pass via
#     splatting (see below.)
$command = 'New-AzureRmResourceGroup'
$commandArgs = [ordered] @{
  Name = $rgFullName
  Location = $location
  Tag = $tags
  Force = $True
}

# Echo the command to be executed.
$command, $commandArgs

# Execute the command, using & and splatting (note the '@' instead of '$')
& $command @commandArgs

The above echoes the following (excluding any output from the actual execution):

New-AzureRmResourceGroup

Name                           Value
----                           -----
Name                           full name
Location                       loc
Tag                            {two, three, one}
Force                          True

As you can see:

• PowerShell's default output formatting results in a multi-line representation of the hashtable used for splatting.

• The $tags entry, a hashtable itself, is unfortunately only represented by its keys - the values are missing.

However, you can customize the output programmatically to create a single-line representation that approximates the command with expanded arguments, including showing hashtables with their values, using helper function convertTo-PseudoCommandLine:

# Helper function that converts a command name and its arguments specified
# via a hashtable or array into a pseudo-command line string that 
# *approximates* the command using literal values.
# Main use is for logging, to reflect commands with their expanded arguments.
function convertTo-PseudoCommandLine ($commandName, $commandArgs) {

  # Helper script block that transforms a single parameter-name/value pair
  # into part of a command line.
  $sbToCmdLineArg = { param($paramName, $arg) 
    $argTransformed = ''; $sep = ' '
    if ($arg -is [Collections.IDictionary]) { # hashtable
      $argTransformed = '@{{{0}}}' -f ($(foreach ($key in $arg.Keys) { '{0}={1}' -f (& $sbToCmdLineArg '' $key), (& $sbToCmdLineArg '' $arg[$key]) }) -join ';')
    } elseif ($arg -is [Collections.ICollection]) { # array / collection
      $argTransformed = $(foreach ($el in $arg) { & $sbToCmdLineArg $el }) -join ','
    }
    elseif ($arg -is [bool]) { # assume it is a switch
      $argTransformed = ('$False', '$True')[$arg]
      $sep = ':' # passing an argument to a switch requires -switch:<val> format
    } elseif ($arg -match '^[$@(]|\s|"') {
      $argTransformed = "'{0}'" -f ($arg -replace "'", "''") # single-quote and escape embedded single quotes
    } else {
      $argTransformed = "$arg" # stringify as is - no quoting needed
    }
    if ($paramName) { # a parameter-argument pair
      '-{0}{1}{2}' -f $paramName, $sep, $argTransformed
    } else { # the command name or a hashtable key or value
      $argTransformed
    }
  }

  # Synthesize and output the pseudo-command line.
  $cmdLine = (& $sbToCmdLineArg '' $commandName)
  if ($commandArgs -is [Collections.IDictionary]) { # hashtable
    $cmdLine += ' ' + 
      $(foreach ($param in $commandArgs.Keys) { & $sbToCmdLineArg $param $commandArgs[$param] }) -join ' '
  } elseif ($commandArgs) { # array / other collection
    $cmdLine += ' ' + 
      $(foreach ($arg in $commandArgs) { & $sbToCmdLineArg '' $arg }) -join ' '
  }

  # Output the command line.
  # If the comamnd name ended up quoted, we must prepend '& '
  if ($cmdLine[0] -eq "'") {
    "& $cmdLine"
  } else {
    $cmdLine
  }

}

With convertTo-PseudoCommandLine defined (before or above the code below), you can then use:

# Sample argument values.
$rgFullName = 'full name'
$location = 'loc'
$tags = @{ one = 1; two = 2; three = 3 }

# Define the command to execute:
#   * as a string variable that contains the command name / path
#   * as a hashtable that defines the arguments to pass via
#     splatting (see below.)
$command = 'New-AzureRmResourceGroup'
$commandArgs = [ordered] @{
  Name = $rgFullName
  Location = $location
  Tag = $tags
  Force = $True
}


# Echo the command to be executed as a pseud-command line
# created by the helper function.
convertTo-PseudoCommandLine $command $commandArgs

# Execute the command, using & and splatting (note the '@' instead of '$')
& $command @commandArgs

This yields (excluding any output from the actual execution):

New-AzureRmResourceGroup -Name 'full name' -Location loc -Tag @{two=2;three=3;one=1} -Force:$True