---
# System prepended metadata

title: Tracing log function code in UDM

---

```
cd ~/free5gc/NFs/udm/cmd
nano main.go
```
   - `cd`: Stands for "change directory".
   - `~/free5gc/NFs/udm/cmd`: This is the path to the directory you want to navigate to. The `~` symbol represents the home directory of the current user.
   - This command moves you into the `cmd` directory of the `udm` component within the `NFs` (Network Functions) directory of the `free5gc` project.

   - `nano`: This is a command to open the Nano text editor, which is a simple, user-friendly terminal-based text editor.
   - `main.go`: This is the name of the file you want to edit. In this case, it is the `main.go` file, which is likely the main entry point for the UDM component in the Free5GC project.

1. **Navigates** to the `cmd` directory within the UDM (Unified Data Management) component's directory structure of the Free5GC project.
2. **Opens** the `main.go` file using the Nano text editor for editing.

![image](https://hackmd.io/_uploads/r1WXJ36SA.png)

### UDM Run Error Log function
* Before

```
logger.MainLog.Errorf("UDM Run error: %v\n", err)

```
1. **logger.MainLog**:
   - `logger` is a package or an object that manages logging.
   - `MainLog` is a logging instance or object within the `logger` package. It is typically configured to handle main application logs.

2. **Errorf**:
   - `Errorf` is a method of the `MainLog` object. It is used to log error messages.
   - The `f` in `Errorf` indicates that this method works like `fmt.Printf`, allowing formatted strings.

3. **Log Message**:
   - `"UDM Run error: %v\n"` is the format string for the log message.
   - `UDM Run error:` is a static part of the message, indicating that an error occurred while running the UDM (Unified Data Management) component.
   - `%v` is a placeholder for a value, which will be replaced by the `err` variable.
   - `\n` is a newline character, ensuring the message ends with a newline.

4. **err**:
   - `err` is the variable that holds the error information. It is likely an instance of the `error` interface in Go, which represents an error condition.

* after:
```
logger.MainLog.Errorf("UDM Run error new Dita: %v\n", err)
```

1. **logger.MainLog**:
   - `logger` is a package or an object that manages logging.
   - `MainLog` is a logging instance or object within the `logger` package. It is typically configured to handle main application logs.

2. **Errorf**:
   - `Errorf` is a method of the `MainLog` object. It is used to log error messages.
   - The `f` in `Errorf` indicates that this method works like `fmt.Printf`, allowing formatted strings.

3. **Log Message**:
   - `"UDM Run error new Dita: %v\n"` is the format string for the log message.
   - `UDM Run error new Dita:` is a static part of the message, indicating that an error occurred while running the UDM (Unified Data Management) component.
   - `%v` is a placeholder for a value, which will be replaced by the `err` variable.
   - `\n` is a newline character, ensuring the message ends with a newline.

4. **err**:
   - `err` is the variable that holds the error information. It is likely an instance of the `error` interface in Go, which represents an error condition.

The line of code logs an error message using the `MainLog` logger instance. The message indicates that there was an error while running the UDM component, and it includes the actual error message or details represented by the `err` variable.


- The log message has a specific wording: `"UDM Run error new Dita:"`. This might be a placeholder or a specific term used within your project or organization.
- The `%v` within the string is a format verb that will be replaced by the value of `err`, providing details about the error encountered.
- This log entry helps developers or operators understand that an error occurred during the execution of the UDM component and gives details about the nature of the error.


If `err` contains an error message saying "file not found", the log output would be:

```
UDM Run error new Dita: file not found
```

This provides a clear indication in the logs that the UDM component encountered an error, and specifies what that error was. The addition of "new Dita" might be an internal reference or specific terminology relevant to the context in which this log statement was written.

![image](https://hackmd.io/_uploads/BkqdRjaSC.png)


### UDM version log function
* Before:
```
logger.MainLog.Infoln("UDM version: ", version.GetVersion())
```

1. **logger.MainLog**:
   - `logger` is a package or an object that manages logging.
   - `MainLog` is a logging instance or object within the `logger` package. It is typically configured to handle main application logs.

2. **Infoln**:
   - `Infoln` is a method of the `MainLog` object. It is used to log informational messages.
   - `Infoln` appends a newline character to the end of the message, similar to how `println` works.

3. **Log Message**:
   - `"UDM version: "` is a static part of the message. It indicates that the log entry is about the version of the UDM (Unified Data Management) component.
   - `version.GetVersion()` is a function call that retrieves the version information of the UDM component.

The line of code logs an informational message using the `MainLog` logger instance. The message indicates the current version of the UDM component.

### Key Points

- The **`Infoln`** method is used to log information-level messages, which are typically used to report general operational information about the application.
- **`"UDM version: "`** is the static text that provides context to the log entry, specifying that the message is about the UDM version.
- **`version.GetVersion()`** is a function that returns the version of the UDM component. This is likely a custom function defined elsewhere in your codebase.

If `version.GetVersion()` returns `"1.0.0"`, the log output would be:

```
UDM version: 1.0.0
```

This provides a clear log entry that indicates the version of the UDM component currently running, which can be useful for debugging, monitoring, and verifying the deployment of different versions.

* After:
```
logger.MainLog.Infoln("UDM version (New Dita): ", version.GetVersion())
```



1. **logger.MainLog**:
   - `logger` is a package or an object that manages logging.
   - `MainLog` is a logging instance or object within the `logger` package. It is typically configured to handle main application logs.

2. **Infoln**:
   - `Infoln` is a method of the `MainLog` object. It is used to log informational messages.
   - `Infoln` appends a newline character to the end of the message, similar to how `println` works.

3. **Log Message**:
   - `"UDM version (New Dita): "` is a static part of the message. It indicates that the log entry is about the version of the UDM (Unified Data Management) component and includes a reference to "New Dita".
   - `version.GetVersion()` is a function call that retrieves the version information of the UDM component.



The line of code logs an informational message using the `MainLog` logger instance. The message indicates the current version of the UDM component, specifically labeled as "(New Dita)".


- The **`Infoln`** method is used to log information-level messages, which are typically used to report general operational information about the application.
- **`"UDM version (New Dita): "`** is the static text that provides context to the log entry. The "(New Dita)" part might be a specific tag or version label relevant to the context or a particular deployment stage.
- **`version.GetVersion()`** is a function that returns the version of the UDM component. This is likely a custom function defined elsewhere in your codebase.


If `version.GetVersion()` returns `"1.0.0"`, the log output would be:

```
UDM version (New Dita): 1.0.0
```

This provides a clear log entry that indicates the version of the UDM component currently running, with a specific reference to "New Dita". This could be useful for distinguishing between different builds, versions, or deployment stages, and helps in debugging, monitoring, and verifying the deployment of different versions.


- The term **"New Dita"** could be an internal codename, version tag, or deployment label used within your project or organization to specify a particular version or set of changes in the UDM component.
- The inclusion of such specific labels in logs helps track the usage and performance of different versions or configurations in a live environment.

* Result:
![image](https://hackmd.io/_uploads/rJlnenpB0.png)

* Before : 
```
logger.InitLog.Errorf("Make directory %s failed: %+v", tmpDir, err)
```

1. **logger.InitLog**:
   - `logger` is a package or an object that manages logging.
   - `InitLog` is a logging instance or object within the `logger` package. It is specifically configured to handle initialization-related logs.

2. **Errorf**:
   - `Errorf` is a method of the `InitLog` object. It is used to log error messages.
   - The `f` in `Errorf` indicates that this method works like `fmt.Printf`, allowing formatted strings.

3. **Log Message**:
   - `"Make directory %s failed: %+v"` is the format string for the log message.
   - `Make directory` is a static part of the message, indicating that the error is related to creating a directory.
   - `%s` is a placeholder for a string, which will be replaced by the value of `tmpDir`.
   - `failed:` is another static part of the message.
   - `%+v` is a placeholder for a value, which will be replaced by the `err` variable, providing a detailed representation of the error.

4. **tmpDir**:
   - `tmpDir` is a variable that holds the name or path of the directory that the program attempted to create.

5. **err**:
   - `err` is a variable that holds the error information. It is likely an instance of the `error` interface in Go, which represents an error condition.


The line of code logs an error message using the `InitLog` logger instance. The message indicates that an attempt to create a directory failed, and it includes the name of the directory and detailed error information.


- The **`Errorf`** method is used to log error-level messages, which are typically used to report problems that require attention.
- **`"Make directory %s failed: %+v"`** is the format string for the log message. It specifies that the message will include the directory name and the detailed error information.
- **`tmpDir`** is the directory that the program attempted to create.
- **`err`** provides details about why the directory creation failed.

If `tmpDir` is `/tmp/example` and `err` contains an error message such as "permission denied", the log output would be:

```
Make directory /tmp/example failed: permission denied
```

This provides a clear log entry that indicates an error occurred while trying to create a specific directory and specifies what the error was.

- Logging such messages is crucial for debugging and operational monitoring. It helps developers and system administrators understand what went wrong during the initialization process.
- Including the directory path (`tmpDir`) and detailed error information (`err`) in the log message makes it easier to diagnose and fix issues related to directory creation.

* After : 
```
 logger.InitLog.Errorf("Make directory %s failed(new dita): %+v", tmpDir, err)
```

1. **logger.InitLog**:
   - `logger` is a package or module that manages logging.
   - `InitLog` is a specific logging instance or object configured to handle initialization-related logs. This is usually set up with certain log settings (like log level, output format, etc.).

2. **Errorf**:
   - `Errorf` is a method of the `InitLog` object. It is used to log formatted error messages.
   - The `f` in `Errorf` stands for "formatted", similar to `fmt.Printf`, allowing the use of format specifiers.

3. **Log Message**:
   - `"Make directory %s failed(new dita): %+v"` is the format string for the log message.
     - `"Make directory "`: A static part of the message, indicating that the log entry is about a directory creation attempt.
     - `%s`: A placeholder for a string, which will be replaced by the value of `tmpDir`.
     - `"failed(new dita): "`: A static message prefix that indicates the failure and includes the label "(new dita)".
     - `%+v`: A format verb that prints the error details with a stack trace or detailed error information.

4. **tmpDir**:
   - `tmpDir` is a variable that holds the name or path of the directory that the program tried to create.

5. **err**:
   - `err` is a variable holding the error information, which implements the `error` interface in Go. It typically contains details about what went wrong.


The line of code logs an error message using the `InitLog` logger instance. It provides information about a failed attempt to create a directory, including the directory path and detailed error information, with an additional tag "(new dita)".

- **Logging Context**:
  - **`Errorf`**: Logs an error message with formatting, suitable for detailed error reporting.
  - **Format String**: `"Make directory %s failed(new dita): %+v"` includes placeholders for `tmpDir` and `err`.
    - `%s` is replaced by the string representation of `tmpDir`.
    - `%+v` provides a detailed representation of `err`, often including stack traces or additional error context.

- **Message Details**:
  - **"Make directory %s failed(new dita): "**: Descriptive static text indicating the operation and context. The `(new dita)` part might be a specific tag or reference to a version or phase of development.
  - **`tmpDir`**: The directory path that the program attempted to create.
  - **`err`**: Detailed error information, printed with full details including any stack trace.

If `tmpDir` is `/tmp/example` and `err` contains an error like "permission denied", the log output would be:

```
Make directory /tmp/example failed(new dita): permission denied
```

This log message would clearly indicate that the attempt to create the directory `/tmp/example` failed, with the error message "permission denied", and it specifies that this is related to the "new dita" version or phase.

- **Debugging**: This log entry is crucial for diagnosing why the directory creation failed. It provides clear context and details, making it easier to troubleshoot.
- **Monitoring**: Including tags like "(new dita)" helps in identifying and filtering logs related to specific versions or stages of development, facilitating better monitoring and maintenance.

This detailed logging approach is essential for effective debugging and maintaining the UDM component or any other system handling directory creation.

```
cd ~/free5gc/NFs/udm/pkg/service
```
The command you provided is used to navigate to a specific directory within the `free5gc` project. Here’s a breakdown of what this command does and its context:

### Command Breakdown

```sh
cd ~/free5gc/NFs/udm/pkg/service
```

1. **cd**:
   - `cd` stands for "change directory".
   - This command is used to navigate to a different directory in the filesystem.

2. **~/free5gc/NFs/udm/pkg/service**:
   - `~` (tilde) represents the home directory of the current user.
   - `free5gc` is the name of the root directory for the free5gc project, which is an open-source 5G core network implementation.
   - `NFs` stands for Network Functions. It contains various network function implementations for the 5G core network.
   - `udm` is the Unified Data Management component, which is responsible for handling subscription data management and user data storage.
   - `pkg` is a common naming convention in Go projects that stands for "package". It typically contains reusable code that can be imported into other parts of the application.
   - `service` is a subdirectory that likely contains service-related code for the UDM component.

1. **View or Edit Code**:
   - Open and edit Go files using a text editor like `nano`, `vim`, or an integrated development environment (IDE) like VSCode.

2. **Compile and Run**:
   - Compile and run the UDM service to test changes or start the service as part of the free5gc 5G core network.

3. **Check for Documentation**:
   - Look for README files or other documentation to understand the specific services and functionality implemented in this directory.

4. **Run Tests**:
   - Execute tests to ensure that the service code is functioning correctly and that new changes do not introduce bugs.

 
* Before : 
```
logger.InitLog.Infof("UDM Config Info: Version[%s] Description[%s]", config.Info.Version, config.Info.Description)
```
1. **logger.InitLog**:
   - `logger` is a package or an object that manages logging.
   - `InitLog` is a logging instance or object within the `logger` package, typically configured to handle initialization-related logs.

2. **Infof**:
   - `Infof` is a method of the `InitLog` object. It is used to log informational messages.
   - The `f` in `Infof` indicates that this method works like `fmt.Printf`, allowing formatted strings.

3. **Log Message**:
   - `"UDM Config Info: Version[%s] Description[%s]"` is the format string for the log message.
     - `UDM Config Info:` is a static part of the message, indicating that the log entry is about the configuration information of the UDM (Unified Data Management) component.
     - `Version[%s]` and `Description[%s]` are placeholders that will be replaced by the `Version` and `Description` fields of the `config.Info` object, respectively.

4. **config.Info.Version**:
   - `config` is an object that holds configuration data.
   - `Info` is a field within the `config` object, which contains metadata about the configuration.
   - `Version` is a field within the `Info` object, representing the version of the UDM configuration.

5. **config.Info.Description**:
   - `Description` is another field within the `Info` object, representing a description of the UDM configuration.

The line of code logs an informational message using the `InitLog` logger instance. The message provides details about the UDM configuration, specifically the version and description.

- The **`Infof`** method is used to log information-level messages, which are typically used to report general operational information about the application.
- **Format String**: `"UDM Config Info: Version[%s] Description[%s]"` includes placeholders for the version and description.
  - `%s` placeholders will be replaced by the values of `config.Info.Version` and `config.Info.Description`.
- **`config.Info.Version`** and **`config.Info.Description`**: These fields contain the version and description of the UDM configuration, respectively.

If `config.Info.Version` is `"1.0.0"` and `config.Info.Description` is `"Initial release"`, the log output would be:

```
UDM Config Info: Version[1.0.0] Description[Initial release]
```

This log message provides clear information about the version and description of the UDM configuration, which can be useful for debugging, monitoring, and documentation purposes.

- **Initialization Logs**: This log entry is useful during the initialization phase of the UDM component. It helps verify that the correct configuration is being loaded.
- **Debugging**: In case of issues, having configuration information in the logs can help troubleshoot problems related to incorrect or unexpected configurations.
- **Monitoring**: Regular logs of configuration details help monitor and audit changes in the configuration over time. This is useful for maintaining consistency and ensuring that deployments are using the correct configurations.

This logging approach ensures that important configuration details are recorded, aiding in the effective management and operation of the UDM component.
* After : 
```
logger.InitLog.Infof("UDM Config Info(new dita): Version[%s] Description[%s]", config.Info.Version, config.Info.Description)
```

1. **logger.InitLog**:
   - `logger` is a package or an object that manages logging.
   - `InitLog` is a specific logging instance or object within the `logger` package, typically configured to handle initialization-related logs.

2. **Infof**:
   - `Infof` is a method of the `InitLog` object. It is used to log informational messages.
   - The `f` in `Infof` indicates that this method works like `fmt.Printf`, allowing formatted strings.

3. **Log Message**:
   - `"UDM Config Info(new dita): Version[%s] Description[%s]"` is the format string for the log message.
     - `UDM Config Info(new dita):` is a static part of the message, indicating that the log entry is about the configuration information of the UDM (Unified Data Management) component, with a specific reference to "new dita".
     - `Version[%s]` and `Description[%s]` are placeholders that will be replaced by the `Version` and `Description` fields of the `config.Info` object, respectively.

4. **config.Info.Version**:
   - `config` is an object that holds configuration data.
   - `Info` is a field within the `config` object, which contains metadata about the configuration.
   - `Version` is a field within the `Info` object, representing the version of the UDM configuration.

5. **config.Info.Description**:
   - `Description` is another field within the `Info` object, representing a description of the UDM configuration.



The line of code logs an informational message using the `InitLog` logger instance. The message provides details about the UDM configuration, specifically the version and description, with an additional reference to "new dita".

- The **`Infof`** method is used to log information-level messages, which are typically used to report general operational information about the application.
- **Format String**: `"UDM Config Info(new dita): Version[%s] Description[%s]"` includes placeholders for the version and description.
  - `%s` placeholders will be replaced by the values of `config.Info.Version` and `config.Info.Description`.
- **`config.Info.Version`** and **`config.Info.Description`**: These fields contain the version and description of the UDM configuration, respectively.

If `config.Info.Version` is `"1.0.0"` and `config.Info.Description` is `"Initial release"`, the log output would be:

This log message provides clear information about the version and description of the UDM configuration, with a specific tag "(new dita)". This can be useful for debugging, monitoring, and documentation purposes.

- **Initialization Logs**: This log entry is useful during the initialization phase of the UDM component. It helps verify that the correct configuration is being loaded.
- **Debugging**: In case of issues, having configuration information in the logs can help troubleshoot problems related to incorrect or unexpected configurations.
- **Monitoring**: Regular logs of configuration details help monitor and audit changes in the configuration over time. This is useful for maintaining consistency and ensuring that deployments are using the correct configurations.
- **Versioning**: The specific reference to "new dita" might indicate a new version, deployment phase, or specific configuration set, aiding in distinguishing between different setups or releases.

This logging approach ensures that important configuration details are recorded, aiding in the effective management and operation of the UDM component.

* Result : 

![image](https://hackmd.io/_uploads/rJDN53Tr0.png)
