# Emit logs

> Add custom logging statements to your Cloud Code scripts and modules to record debugging information.

You can emit logs from [Cloud Code scripts](../../scripts/overview) and [modules](../../modules/overview).

## Cloud Code C# modules

You can emit logs from [Cloud Code C# modules](../../modules/overview) by using the [`Microsoft.Extensions.Logging` library](https://learn.microsoft.com/en-us/dotnet/core/extensions/logging?tabs=command-line).
Cloud Code automatically provides your code with a UGS Logger every time you request an `ILogger` through [Dependency Injection](../../modules/how-to-guides/initialize-modules/dependency-injection).

The following code sample shows everything you need to do to instrument C# modules:

```csharp
using Microsoft.Extensions.Logging;
using Unity.Services.CloudCode.Core;

namespace CloudCodeModules;

public class LoggingExample
{
    // Setting up the Dependency Injection. Cloud Code will inject a UGS Logger
    // into "_logger" which can then be used by all methods in this class
    private readonly ILogger<LoggingExample> _logger;
    public LoggingExample(ILogger<LoggingExample> logger)
    {
        _logger = logger;
    }

    [CloudCodeFunction("SayHello")]
    public string SayHello(IExecutionContext ctx, string name)
    {
        // Logging out a standard message
        _logger.LogDebug("received a request to SayHello");

        // Logging out a templated message. The template variable "name"
        // will be available as a key-value pair inside the log attributes map.
        // Templated keys cannot use dot notation for namespacing.
        _logger.LogInformation("saying hello to {name}", name);

        // A scope can be used to share sets of attributes between multiple log
        // entries. Attribute keys in a scope can use dot notation for namespacing
        // purposes.
        using (_logger.BeginScope(new Dictionary<string, object>
            {
                {"example.someInteger", 7 },
                {"example.someString", "frog blast the vent core!" }
            }))
        {
            _logger.LogInformation("logging within a scope");
            _logger.LogInformation("logging again with the same attributes");
        }

        return $"Hello, {name}!";
    }
}
```

## Cloud Code JavaScript scripts

You can emit logs from [Cloud Code JavaScript scripts](../../scripts/overview) by using the default logger provided automatically as part of the script context.

The following code sample shows everything you need to do to instrument JavaScript scripts:

### JavaScript

```javascript
module.exports = async ({ params, context, logger }) => {
    logger.info("script executing", {"example.someString": "frog blast the vent core!"});
    logger.warning("this is a serious warning that the cheese is about to run out.");
    logger.error("out of cheese :(", {"example.foo": 42}, {"example.bar": 7});
};
```

The logger provides the following methods:

* `debug(message, ...logAttributes)`
* `info(message, ...logAttributes)`
* `warning(message, ...logAttributes)`
* `error(message, ...logAttributes)`
* `fatal(message, ...logAttributes)`

### Limits

You can pass multiple log attributes per call, however, the following restrictions apply:

* Each log attribute must be an object with a single key/value pair.
* The value must be a non-empty primitive (false booleans are allowed).