ninjarobot

---
- hosts: all
  tasks:
  - name: Download MS product repository
    get_url:
      url: https://packages.microsoft.com/config/ubuntu/18.04/packages-microsoft-prod.deb
      dest: /tmp/packages-microsoft-prod.deb
  - name: Install MS product repository
    apt: deb=/tmp/packages-microsoft-prod.deb
    become: true

ninjarobot

let sleepOnError fn =
    async {
        let! (res:Result<_,_>) = fn
        return!
            match res with
            | Ok o -> async.Return (Ok o)
            | Error e ->
                async {
                    do! Async.Sleep 750
                    return Error e

ninjarobot

FROM alpine
RUN echo 'using System; \
namespace Program { \
  public class MyClass { \
    public static void Main(string[] args) { \
      Console.WriteLine ("Hello from C#"); \
    } \
  } \
}' >> Program.cs
RUN apk add  --virtual build-dependencies --repository http://dl-cdn.alpinelinux.org/alpine/edge/testing --no-cache mono mono-dev musl-dev binutils gcc && \

ninjarobot

Tracing with Application Insights

Application logging is ubiquitous and invaluable for troubleshooting. Structured logging enables you to log formatted messages and the data fields separately so that you can see the messages but also filter on the data fields. Tracing takes this a step further, where you can correlate many log entries together as you follow a trace of execution through an application. Traces also include additional information about the execution process, such as the sequence of calls to dependencies and how long any given call may take.

Application Insights lets you see all of this data correlated together in an application. You can search for an error log and then see in the execution flow that the log entry was added right after a failed call to another service. Or you can see that a certain web request is slower than others because it spends a lot of time on many redundant data access calls.

What about OpenTelemetry?

ninjarobot

HOME:=$(shell pwd)
NAME:=someLargeProject
DOCKER_REPO := my.internal.repo
DOCKER_REPO_DIR := mystuff
BUILD_CONTAINER := microsoft/dotnet:2-sdk

BASE_VERSION = 2.0
BUILD_NUMBER ?= 1
VERSION = ${BASE_VERSION}.${BUILD_NUMBER}

ninjarobot

namespace AzurefnSecret

open Microsoft.Azure.KeyVault
open Microsoft.IdentityModel.Clients.ActiveDirectory

module Example =
    let getSecret (appKeyDescription:string) (appKeyValue:string) (secretUrl:string) =
        async {
            use keyVault = new KeyVaultClient(fun authority resource (_:string) ->
                async {

ninjarobot

open Microsoft.Extensions.Configuration

/// Builds a configuration source from raw JSON.
let configSourceFromJson (json:string) : IConfigurationSource =
    { new IConfigurationSource with
            member this.Build (builder:IConfigurationBuilder) =
                { new ConfigurationProvider() with
                    member this.Load() =
                        this.Data <- Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string,string>> json
                } :> IConfigurationProvider

ninjarobot

# default target so running 'make' by itself wll download and build nginx
build: nginx
	cd nginx && ./configure --with-pcre=../pcre2 && make

nginx: pcre2
	curl -O https://nginx.org/download/nginx-1.21.6.tar.gz
	tar -xzvf nginx-*.tar.gz
	mv nginx-*/ nginx
	rm nginx-*.tar.gz

ninjarobot

ninjarobot

Trace .NET Core Applications on Linux with strace

Troubleshooting a running application can be difficult, usually it starts around checking log output and then following through the likely code paths to get an idea of where a failure may occur. In a development environment, you might attach a debugger a step through source, but troubleshooting isn't always that convenient. There are several helpful tools that can assist, but one that gives the most comprehensive view of a running application is strace. With strace you are able to see all of the system calls an application makes to get a detailed understanding of what is going on "under the hood" in order to troubleshoot an issue.

Take a simple "hello world" F# application, the kind you get from dotnet new console -lang F# -n strace-sample". Build it with dotnet build and then launch it with strace to get a trace of all the system calls in a file called trace.log(adjusting for your build output path if on a different framework vers