Skip to content

Latest commit

 

History

History
808 lines (582 loc) · 34.2 KB

compute.md

File metadata and controls

808 lines (582 loc) · 34.2 KB

sf compute

Manage Salesforce Compute apps.

sf compute create telemetry-drain

Add a telemetry drain to a compute app.

USAGE
  $ sf compute create telemetry-drain --url <value> -o <value> [--json] [--flags-dir <value>] [-n <value>] [--signals <value>]
    [--transport <value>] [--header <value>...] [--api-version <value>]

FLAGS
  -n, --name=<value>         [env: COMPUTE_APP_NAME] DeveloperName of the compute app to add the drain to (or
                             <namespace>\_\_<developerName> if it was deployed under a namespace).
                             Defaults to the COMPUTE_APP_NAME environment variable, or the current
                             directory's app name if that isn't set either.
  -o, --target-org=<value>   (required) Username or alias of the target org. Not required if the `target-org`
                             configuration variable is already set.
      --api-version=<value>  Override the api version used for api requests made by this command
      --header=<value>...    Header to send with each export, as key=value.
      --signals=<value>      [default: all] Comma-separated signals to forward: traces, metrics, logs, or all.
      --transport=<value>    [default: http] Wire protocol to use: http (OTLP over HTTP) or grpc (OTLP over gRPC).
      --url=<value>          (required) Endpoint to forward telemetry to.

GLOBAL FLAGS
  --flags-dir=<value>  Import flag values from a directory.
  --json               Format output as json.

DESCRIPTION
  Add a telemetry drain to a compute app.

  Creates an OpenTelemetry drain that forwards the compute app's logs, metrics,
  and traces to the endpoint you give with --url. Choose which signals to
  forward with --signals and the wire protocol with --transport. Use
  sf compute update telemetry-drain to change a drain later.

EXAMPLES
  Forward all signals from a compute app to an OTLP/HTTP collector:

    $ sf compute create telemetry-drain --name CreditRatingScorer --url https://collector.example.com:4318 \
      --target-org my-org

  Forward only traces and logs over gRPC, with an auth header:

    $ sf compute create telemetry-drain --name CreditRatingScorer --url https://collector.example.com:4317 \
      --transport grpc --signals traces,logs --header "x-api-key=my-key" --target-org my-org

FLAG DESCRIPTIONS
  --header=<value>...  Header to send with each export, as key=value.

    Repeat the flag to send more than one header. Header values often carry
    credentials; they are sent to the endpoint and are never printed to the
    terminal or --json output; header keys are preserved with redacted values.

See code: src/commands/compute/create/telemetry-drain.ts

sf compute delete telemetry-drain ID

Delete a compute telemetry drain.

USAGE
  $ sf compute delete telemetry-drain ID -o <value> [--json] [--flags-dir <value>] [-p] [--api-version <value>]

FLAGS
  -o, --target-org=<value>   (required) Username or alias of the target org. Not required if the `target-org`
                             configuration variable is already set.
  -p, --no-prompt            Don't ask for confirmation before deleting.
      --api-version=<value>  Override the api version used for api requests made by this command

GLOBAL FLAGS
  --flags-dir=<value>  Import flag values from a directory.
  --json               Format output as json.

DESCRIPTION
  Delete a compute telemetry drain.

  Removes a single OpenTelemetry drain by its ID, so its compute app stops
  forwarding logs, metrics, and traces to the drain's endpoint. This can't be
  undone; to forward telemetry again, create a new drain. You're asked to
  confirm first unless you pass --no-prompt. Use sf compute list telemetry-drain
  to find a drain's ID.

EXAMPLES
  Delete a telemetry drain, confirming first:

    $ sf compute delete telemetry-drain 01234567-89ab-cdef-0123-456789abcdef --target-org my-org

  Delete a telemetry drain without the confirmation prompt, for scripts:

    $ sf compute delete telemetry-drain 01234567-89ab-cdef-0123-456789abcdef --target-org my-org --no-prompt

See code: src/commands/compute/delete/telemetry-drain.ts

sf compute deploy

Show how to deploy a compute app.

USAGE
  $ sf compute deploy [--json] [--flags-dir <value>]

GLOBAL FLAGS
  --flags-dir=<value>  Import flag values from a directory.
  --json               Format output as json.

DESCRIPTION
  Show how to deploy a compute app.

  This command no longer deploys compute apps. Install the Compute variant of
  the deploy-retrieve plugin and use project deploy start from your Salesforce
  DX project instead.

EXAMPLES
  Install the plugin and deploy a compute app:

    $ sf plugins install @salesforce/plugin-deploy-retrieve@compute
    $ sf project deploy start --metadata ComputeApp:my_app --target-org my-org

See code: src/commands/compute/deploy.ts

sf compute display

Show the current org-side status of a deployed compute app.

USAGE
  $ sf compute display -o <value> [--json] [--flags-dir <value>] [-n <value>] [--api-version <value>] [-v]

FLAGS
  -n, --name=<value>         [env: COMPUTE_APP_NAME] DeveloperName of the compute app to show status for (or
                             <namespace>\_\_<developerName> if it was deployed under a namespace).
                             Defaults to the COMPUTE_APP_NAME environment variable, or the current
                             directory's app name if that isn't set either.
  -o, --target-org=<value>   (required) Username or alias of the target org. Not required if the `target-org`
                             configuration variable is already set.
  -v, --verbose              Also show external service registration and current build detail.
      --api-version=<value>  Override the api version used for api requests made by this command

GLOBAL FLAGS
  --flags-dir=<value>  Import flag values from a directory.
  --json               Format output as json.

DESCRIPTION
  Show the current org-side status of a deployed compute app.

  Queries the org for the compute app's current deployment status: its master
  label, description, and overall status. With --verbose, also shows whether
  an external service has been registered for it (and whether it's active),
  plus the phase, timestamps, and error detail of its current build.

  This is a read-only, live lookup by --name (the app's DeveloperName) -- it
  doesn't read from or require a local Salesforce DX project.

EXAMPLES
  Show the current status of a compute app:

    $ sf compute display --name CreditRatingScorer --target-org my-org

  Include external service and current build detail:

    $ sf compute display --name CreditRatingScorer --target-org my-org --verbose

See code: src/commands/compute/display.ts

sf compute display telemetry-drain ID

Show the full detail of a single compute telemetry drain.

USAGE
  $ sf compute display telemetry-drain ID -o <value> [--json] [--flags-dir <value>] [--api-version <value>]

FLAGS
  -o, --target-org=<value>   (required) Username or alias of the target org. Not required if the `target-org`
                             configuration variable is already set.
      --api-version=<value>  Override the api version used for api requests made by this command

GLOBAL FLAGS
  --flags-dir=<value>  Import flag values from a directory.
  --json               Format output as json.

DESCRIPTION
  Show the full detail of a single compute telemetry drain.

  Shows a single OpenTelemetry drain in full: the compute app it belongs to,
  the signals it forwards, and its exporter endpoint, transport, and headers.
  Use sf compute list telemetry-drain to find a drain's ID.
  Header values are redacted in both human-readable and --json output; header keys are preserved.

EXAMPLES
  Show the detail of a telemetry drain by its ID:

    $ sf compute display telemetry-drain 01234567-89ab-cdef-0123-456789abcdef --target-org my-org

See code: src/commands/compute/display/telemetry-drain.ts

sf compute generate

Scaffold a new compute app into your Salesforce DX project.

USAGE
  $ sf compute generate -n <value> [--json] [--flags-dir <value>] [-d <value>] [-l node|python]

FLAGS
  -d, --output-dir=<value>  [default: force-app/main/default/computeApps] Directory to create the app in.
  -l, --language=<option>   [default: node] Language to scaffold the starter project in.
                            <options: node|python>
  -n, --name=<value>        (required) Name for the new compute app. Use <namespace>\_\_<developerName> to scaffold
                            it under a namespace.

GLOBAL FLAGS
  --flags-dir=<value>  Import flag values from a directory.
  --json               Format output as json.

DESCRIPTION
  Scaffold a new compute app into your Salesforce DX project.

  Creates the app directory under force-app/main/default/computeApps/<name>/ (or
  --output-dir) with a compute metadata file, a Procfile, a project.toml, and
  starter source in the language you choose with --language. No org is
  contacted, but this command does fetch the starter source for the chosen
  language from its Heroku AppLink reference app on GitHub, so it requires
  outbound network access.

  This command is deprecated but still works. When you move to sf template generate
  project --template compute, note that --language no longer defaults to node: the
  replacement's --compute-language flag makes the language an explicit choice.

EXAMPLES
  Scaffold a Node.js compute app named CreditRatingScorer:

    $ sf compute generate --name CreditRatingScorer

  Scaffold a Python compute app into a custom directory:

    $ sf compute generate --name ReceiptOcr --language python --output-dir \
      force-app/main/default/computeApps/scorers

FLAG DESCRIPTIONS
  -d, --output-dir=<value>  Directory to create the app in.

    Defaults to force-app/main/default/computeApps. The app itself is created in a
    subdirectory named after --name.

  -l, --language=node|python  Language to scaffold the starter project in.

    Compute apps can run any Heroku-supported language, but generate currently
    scaffolds starters for node and python only.

See code: src/commands/compute/generate.ts

sf compute get build-log

Print the build/compile log for a compute app's latest build.

USAGE
  $ sf compute get build-log -o <value> [--json] [--flags-dir <value>] [-n <value>] [--api-version <value>]

FLAGS
  -n, --name=<value>         [env: COMPUTE_APP_NAME] DeveloperName of the compute app to fetch build output for (or
                             <namespace>\_\_<developerName> if it was deployed under a namespace).
                             Defaults to the COMPUTE_APP_NAME environment variable, or the current
                             directory's app name if that isn't set either.
  -o, --target-org=<value>   (required) Username or alias of the target org. Not required if the `target-org`
                             configuration variable is already set.
      --api-version=<value>  Override the api version used for api requests made by this command

GLOBAL FLAGS
  --flags-dir=<value>  Import flag values from a directory.
  --json               Format output as json.

DESCRIPTION
  Print the build/compile log for a compute app's latest build.

  Fetches the bounded build/compile log (dependency install, slug compile,
  release) for the most recent build of a compute app -- useful right after
  deploy to confirm the build compiled. This is a one-shot fetch of a
  finished-or-in-progress log, not a live stream; use compute tail runtime-log
  for the ongoing runtime log.

  This is a read-only, org-mediated lookup by --name (the app's DeveloperName)
  -- the org calls Heroku's Build Info API on your behalf. It doesn't read from
  or require a local Salesforce DX project.

EXAMPLES
  Print the latest build's log:

    $ sf compute get build-log --name CreditRatingScorer --target-org my-org

See code: src/commands/compute/get/build-log.ts

sf compute get config [KEY]

Print one or more of a compute app's config var values.

USAGE
  $ sf compute get config [KEY...] -o <value> [--json] [--flags-dir <value>] [-n <value>] [--api-version <value>]

FLAGS
  -n, --name=<value>         [env: COMPUTE_APP_NAME] DeveloperName of the compute app to read config from (or
                             <namespace>\_\_<developerName> if it was deployed under a namespace).
                             Defaults to the COMPUTE_APP_NAME environment variable, or the current
                             directory's app name if that isn't set either.
  -o, --target-org=<value>   (required) Username or alias of the target org. Not required if the `target-org`
                             configuration variable is already set.
      --api-version=<value>  Override the api version used for api requests made by this command

GLOBAL FLAGS
  --flags-dir=<value>  Import flag values from a directory.
  --json               Format output as json.

DESCRIPTION
  Print one or more of a compute app's config var values.

  Goes through the target org's Salesforce Connect API, which calls Heroku on
  your behalf. Pass a single key to print its bare value, or more than one to
  print each as key: value. Fails if any requested key isn't currently set.

EXAMPLES
  Print a single config var's value:

    $ sf compute get config STRIPE_KEY --name CreditRatingScorer --target-org my-org

  Print more than one config var:

    $ sf compute get config STRIPE_KEY LOG_LEVEL --name CreditRatingScorer --target-org my-org

See code: src/commands/compute/get/config.ts

sf compute get runtime-log

Print the recent runtime log for a compute app.

USAGE
  $ sf compute get runtime-log -o <value> [--json] [--flags-dir <value>] [-n <value>] [--api-version <value>] [--num
  <value>]

FLAGS
  -n, --name=<value>         [env: COMPUTE_APP_NAME] DeveloperName of the compute app to fetch logs for (or
                             <namespace>\_\_<developerName> if it was deployed under a namespace).
                             Defaults to the COMPUTE_APP_NAME environment variable, or the current
                             directory's app name if that isn't set either.
  -o, --target-org=<value>   (required) Username or alias of the target org. Not required if the `target-org`
                             configuration variable is already set.
      --api-version=<value>  Override the api version used for api requests made by this command
      --num=<value>          [default: 100] Number of recent log lines to print.

GLOBAL FLAGS
  --flags-dir=<value>  Import flag values from a directory.
  --json               Format output as json.

DESCRIPTION
  Print the recent runtime log for a compute app.

  Fetches a compute app's runtime log -- the app's ongoing output (request
  handling, application logs), not the build/compile log; use compute get
  build-log for that.

  This prints the most recent log lines and exits. To keep the session open and
  stream new lines as they arrive, use compute tail runtime-log.

  The recent lines come from the Cedar log buffer (about 1500 lines at most), so
  --num can't return more than that. Fir apps keep no log history, so for them
  the command reads the live log session instead and stops once it goes quiet
  for a few seconds; it can only show output the session delivers in that
  window, so --num doesn't apply; use compute tail runtime-log to follow a Fir app's log. The
  command stops waiting after 30 seconds and prints whatever log lines it has
  received by then; if none arrived, it fails with a timeout error.

  This is an org-mediated operation by --name (the app's DeveloperName) -- the
  org creates a log session with Heroku on your behalf and hands back a
  short-lived, pre-authorized URL that the CLI reads from directly. It doesn't
  read from or require a local Salesforce DX project.

EXAMPLES
  Print the most recent log lines:

    $ sf compute get runtime-log --name CreditRatingScorer --target-org my-org

  Print the most recent 500 log lines:

    $ sf compute get runtime-log --name CreditRatingScorer --num 500 --target-org my-org

See code: src/commands/compute/get/runtime-log.ts

sf compute list

List the compute apps deployed in an org.

USAGE
  $ sf compute list -o <value> [--json] [--flags-dir <value>] [--api-version <value>]

FLAGS
  -o, --target-org=<value>   (required) Username or alias of the target org. Not required if the `target-org`
                             configuration variable is already set.
      --api-version=<value>  Override the api version used for api requests made by this command

GLOBAL FLAGS
  --flags-dir=<value>  Import flag values from a directory.
  --json               Format output as json.

DESCRIPTION
  List the compute apps deployed in an org.

  Queries the org for every compute app (PlatformComputeApp). The table shows
  each app's master label, status, and status reason; for description, external
  service registration, and current build detail on a single app, use compute
  display (the full detail is also available here via --json).

  This is a read-only, live lookup -- it doesn't read from or require a local
  Salesforce DX project.

EXAMPLES
  List the compute apps in an org:

    $ sf compute list --target-org my-org

See code: src/commands/compute/list.ts

sf compute list config

List a compute app's config vars.

USAGE
  $ sf compute list config -o <value> [--json] [--flags-dir <value>] [-n <value>] [--api-version <value>]

FLAGS
  -n, --name=<value>         [env: COMPUTE_APP_NAME] DeveloperName of the compute app to list config vars for (or
                             <namespace>\_\_<developerName> if it was deployed under a namespace).
                             Defaults to the COMPUTE_APP_NAME environment variable, or the current
                             directory's app name if that isn't set either.
  -o, --target-org=<value>   (required) Username or alias of the target org. Not required if the `target-org`
                             configuration variable is already set.
      --api-version=<value>  Override the api version used for api requests made by this command

GLOBAL FLAGS
  --flags-dir=<value>  Import flag values from a directory.
  --json               Format output as json.

DESCRIPTION
  List a compute app's config vars.

  Shows every config var (environment variable) currently set for a deployed
  compute app, sorted alphabetically. Goes through the target org's Salesforce
  Connect API, which calls Heroku on your behalf. Use sf compute get config to
  read a single var's value, sf compute set config to add or change vars, or
  sf compute unset config to remove them.

EXAMPLES
  List all config vars for a compute app:

    $ sf compute list config --name CreditRatingScorer --target-org my-org

See code: src/commands/compute/list/config.ts

sf compute list telemetry-drain

List the telemetry drains configured for a compute app.

USAGE
  $ sf compute list telemetry-drain -o <value> [--json] [--flags-dir <value>] [-n <value>] [--api-version <value>]

FLAGS
  -n, --name=<value>         [env: COMPUTE_APP_NAME] DeveloperName of the compute app to list telemetry drains for (or
                             <namespace>\_\_<developerName> if it was deployed under a namespace).
                             Defaults to the COMPUTE_APP_NAME environment variable, or the current
                             directory's app name if that isn't set either.
  -o, --target-org=<value>   (required) Username or alias of the target org. Not required if the `target-org`
                             configuration variable is already set.
      --api-version=<value>  Override the api version used for api requests made by this command

GLOBAL FLAGS
  --flags-dir=<value>  Import flag values from a directory.
  --json               Format output as json.

DESCRIPTION
  List the telemetry drains configured for a compute app.

  Shows every OpenTelemetry drain forwarding the compute app's logs, metrics,
  and traces, with each drain's ID, signals, and endpoint. Use
  sf compute display telemetry-drain to see the full detail of a single drain.

EXAMPLES
  List the telemetry drains for a compute app:

    $ sf compute list telemetry-drain --name CreditRatingScorer --target-org my-org

See code: src/commands/compute/list/telemetry-drain.ts

sf compute scale

Resize or rescale a compute app's dyno formation.

USAGE
  $ sf compute scale -o <value> --process-type <value> [--json] [--flags-dir <value>] [-n <value>] [--api-version
    <value>] [--quantity <value>] [--size <value>]

FLAGS
  -n, --name=<value>          [env: COMPUTE_APP_NAME] DeveloperName of the compute app to scale (or
                              <namespace>\_\_<developerName>
                              if it was deployed under a namespace). Defaults to the COMPUTE_APP_NAME
                              environment variable, or the current directory's app name if that isn't set
                              either.
  -o, --target-org=<value>    (required) Username or alias of the target org. Not required if the `target-org`
                              configuration variable is already set.
      --api-version=<value>   Override the api version used for api requests made by this command
      --process-type=<value>  (required) Process type to scale, for example web or worker.
      --quantity=<value>      Number of dynos to run for the process type (0 stops all dynos of that type).
      --size=<value>          Dyno size to run the process type on, for example dyno-1c-4gb.

GLOBAL FLAGS
  --flags-dir=<value>  Import flag values from a directory.
  --json               Format output as json.

DESCRIPTION
  Resize or rescale a compute app's dyno formation.

  Updates a single process type's dyno size and/or quantity for a deployed
  compute app. Pass the process type with --process-type and at least one of
  --quantity or --size. This goes through the target org's Salesforce Connect
  API, which calls Heroku on your behalf.

EXAMPLES
  Change a process type's dyno size:

    $ sf compute scale --process-type web --size dyno-2c-8gb --name CreditRatingScorer --target-org my-org

  Scale a process type's dyno count:

    $ sf compute scale --process-type worker --quantity 3 --name CreditRatingScorer --target-org my-org

  Change size and quantity together:

    $ sf compute scale --process-type web --quantity 2 --size dyno-4c-16gb --name CreditRatingScorer --target-org \
      my-org

  Stop all dynos of a process type:

    $ sf compute scale --process-type worker --quantity 0 --name CreditRatingScorer --target-org my-org

See code: src/commands/compute/scale.ts

sf compute set config [PAIR]

Set one or more of a compute app's config vars.

USAGE
  $ sf compute set config [PAIR...] -o <value> [--json] [--flags-dir <value>] [-n <value>] [--api-version <value>]

FLAGS
  -n, --name=<value>         [env: COMPUTE_APP_NAME] DeveloperName of the compute app to change config for (or
                             <namespace>\_\_<developerName> if it was deployed under a namespace).
                             Defaults to the COMPUTE_APP_NAME environment variable, or the current
                             directory's app name if that isn't set either.
  -o, --target-org=<value>   (required) Username or alias of the target org. Not required if the `target-org`
                             configuration variable is already set.
      --api-version=<value>  Override the api version used for api requests made by this command

GLOBAL FLAGS
  --flags-dir=<value>  Import flag values from a directory.
  --json               Format output as json.

DESCRIPTION
  Set one or more of a compute app's config vars.

  Goes through the target org's Salesforce Connect API, which calls Heroku on
  your behalf. Setting a config var restarts the app's dynos so the new value
  takes effect. Pass one or more KEY=VALUE pairs; a key that doesn't already
  exist is created.

EXAMPLES
  Set a single config var:

    $ sf compute set config STRIPE_KEY=sk_live_xyz789 --name CreditRatingScorer --target-org my-org

  Set more than one config var in one command:

    $ sf compute set config STRIPE_KEY=sk_live_xyz789 LOG_LEVEL=debug --name CreditRatingScorer --target-org my-org

See code: src/commands/compute/set/config.ts

sf compute source retrieve

Retrieve a compute app's source and metadata from an org into your local Salesforce DX project.

USAGE
  $ sf compute source retrieve -n <value> -o <value> [--json] [--flags-dir <value>] [--api-version <value>] [-d <value>]

FLAGS
  -d, --output-dir=<value>   [default: force-app/main/default/computeApps] Directory to create the app in.
  -n, --name=<value>         (required) DeveloperName of the compute app to retrieve (or <namespace>\_\_<developerName>
                             if it was deployed under a namespace).
  -o, --target-org=<value>   (required) Username or alias of the target org. Not required if the `target-org`
                             configuration variable is already set.
      --api-version=<value>  Override the api version used for api requests made by this command

GLOBAL FLAGS
  --flags-dir=<value>  Import flag values from a directory.
  --json               Format output as json.

DESCRIPTION
  Retrieve a compute app's source and metadata from an org into your local Salesforce DX project.

  Creates the compute app's directory under force-app/main/default/computeApps/<name>/
  (or --output-dir), retrieves its <name>.computeApp-meta.xml through the Metadata
  API, then downloads its source code through the Connect API and extracts it
  into that same directory. Deploy it with project deploy start.

EXAMPLES
  Retrieve a compute app's source and metadata from an org:

    $ sf compute source retrieve --name CreditRatingScorer --target-org my-org

FLAG DESCRIPTIONS
  -d, --output-dir=<value>  Directory to create the app in.

    Defaults to force-app/main/default/computeApps. The app itself is created in a
    subdirectory named after --name.

See code: src/commands/compute/source/retrieve.ts

sf compute tail runtime-log

Stream the live runtime log for a compute app.

USAGE
  $ sf compute tail runtime-log -o <value> [--flags-dir <value>] [-n <value>] [--api-version <value>] [--num <value>]

FLAGS
  -n, --name=<value>         [env: COMPUTE_APP_NAME] DeveloperName of the compute app to tail logs for (or
                             <namespace>\_\_<developerName> if it was deployed under a namespace).
                             Defaults to the COMPUTE_APP_NAME environment variable, or the current
                             directory's app name if that isn't set either.
  -o, --target-org=<value>   (required) Username or alias of the target org. Not required if the `target-org`
                             configuration variable is already set.
      --api-version=<value>  Override the api version used for api requests made by this command
      --num=<value>          [default: 100] Number of recent log lines to print before streaming new output.

GLOBAL FLAGS
  --flags-dir=<value>  Import flag values from a directory.

DESCRIPTION
  Stream the live runtime log for a compute app.

  Streams a compute app's runtime log -- the app's ongoing output (request
  handling, application logs), not the build/compile log; use compute get
  build-log for that.

  Keeps the session open and prints new log lines as they arrive, until you stop
  it with Ctrl-C or the session ends on its own. For a one-time snapshot of the
  most recent lines, use compute get runtime-log.

  This is an org-mediated operation by --name (the app's DeveloperName) -- the
  org creates a log session with Heroku on your behalf and hands back a
  short-lived, pre-authorized URL that the CLI reads from directly. It doesn't
  read from or require a local Salesforce DX project.

EXAMPLES
  Tail the log until stopped with Ctrl-C:

    $ sf compute tail runtime-log --name CreditRatingScorer --target-org my-org

  Print the most recent 500 lines, then keep streaming:

    $ sf compute tail runtime-log --name CreditRatingScorer --num 500 --target-org my-org

See code: src/commands/compute/tail/runtime-log.ts

sf compute unset config [KEY]

Unset one or more of a compute app's config vars.

USAGE
  $ sf compute unset config [KEY...] -o <value> [--json] [--flags-dir <value>] [-n <value>] [--api-version <value>]

FLAGS
  -n, --name=<value>         [env: COMPUTE_APP_NAME] DeveloperName of the compute app to change config for (or
                             <namespace>\_\_<developerName> if it was deployed under a namespace).
                             Defaults to the COMPUTE_APP_NAME environment variable, or the current
                             directory's app name if that isn't set either.
  -o, --target-org=<value>   (required) Username or alias of the target org. Not required if the `target-org`
                             configuration variable is already set.
      --api-version=<value>  Override the api version used for api requests made by this command

GLOBAL FLAGS
  --flags-dir=<value>  Import flag values from a directory.
  --json               Format output as json.

DESCRIPTION
  Unset one or more of a compute app's config vars.

  Goes through the target org's Salesforce Connect API, which calls Heroku on
  your behalf. Unsetting a config var restarts the app's dynos so the removal
  takes effect. Fails if any requested key isn't currently set.

EXAMPLES
  Unset a single config var:

    $ sf compute unset config LOG_LEVEL --name CreditRatingScorer --target-org my-org

  Unset more than one config var in one command:

    $ sf compute unset config LOG_LEVEL DEBUG_MODE --name CreditRatingScorer --target-org my-org

See code: src/commands/compute/unset/config.ts

sf compute update telemetry-drain ID

Change the configuration of a compute telemetry drain.

USAGE
  $ sf compute update telemetry-drain ID -o <value> [--json] [--flags-dir <value>] [--url <value>] [--signals <value>] [--transport
    <value>] [--header <value>...] [--api-version <value>]

FLAGS
  -o, --target-org=<value>   (required) Username or alias of the target org. Not required if the `target-org`
                             configuration variable is already set.
      --api-version=<value>  Override the api version used for api requests made by this command
      --header=<value>...    Header to send with each export, as key=value.
      --signals=<value>      New comma-separated signals to forward: traces, metrics, logs, or all.
      --transport=<value>    New wire protocol: http (OTLP over HTTP) or grpc (OTLP over gRPC).
      --url=<value>          New endpoint to forward telemetry to.

GLOBAL FLAGS
  --flags-dir=<value>  Import flag values from a directory.
  --json               Format output as json.

DESCRIPTION
  Change the configuration of a compute telemetry drain.

  Updates only the attributes you pass and leaves the rest of the drain as it
  is. Passing --header adds or overwrites the headers you give and keeps the
  drain's other headers. Use sf compute list telemetry-drain to find a drain's ID.

EXAMPLES
  Point a drain at a new endpoint:

    $ sf compute update telemetry-drain 01234567-89ab-cdef-0123-456789abcdef --url \
      https://collector.example.com:4318 --target-org my-org

  Forward only logs over gRPC:

    $ sf compute update telemetry-drain 01234567-89ab-cdef-0123-456789abcdef --signals logs --transport grpc \
      --target-org my-org

FLAG DESCRIPTIONS
  --header=<value>...  Header to send with each export, as key=value.

    Repeat the flag to send more than one header. A header you pass adds
    or overwrites the one with the same name; the drain's other headers are kept. Header values often carry credentials;
    they are
    never printed to the terminal or --json output; header keys are preserved with redacted values.

See code: src/commands/compute/update/telemetry-drain.ts