DEV Community: HM

Data vs Application Integration

HM — Wed, 30 Aug 2023 02:47:31 +0000

I often see people use the two terms interchangeably, leading to dilution of the message. Often, causing confusion.

In this post, I attempt to bring some clarity given the context of data movement.

Data is used in two contexts: operational and analytical.

The operational context is part of a bigger business process e.g. order placement. Here the applications need to talk to each other, share data to achieve/contribute to a business process e.g. for the customer to place an order, the order system needs to know what products and inventory exists
The analytical context may or may not be part of the business process, and usually involves extracting some insight from the data. e.g. measuring demand based on the order history of products can be used to either feed back into pricing process (business process) or simply used to report on growth

In the earlier days, and to some extend even today, data movement in both the contexts would involve some kind of extract, transform and load process (ETL - more on it soon). More often than not, the medium of transport would be (flat) file.
In modern architectures, however, the process may involve push or pull, synchronous or asynchronous exchange of data over the network. The medium of transport then usually is APIs or Messages (more on them soon).

ETL - ETL is an umbrella term used for a process that utilises a middleware to perform the data transfer. The middleware may directly connect with systems/databases and relay the data over the network or use file as a medium of transport.

APIs and Messages - APIs and messages (in a simplistic view) allow systems to talk directly with each other. In the real world, there will be an integration tool and a message broker that facilitates this.

The theoretical difference
While application integration deals with connecting systems for the purpose of achieving a business process, data integration deal with combining data for the purpose of making it available for an operational or analytical purpose.

The practical difference
Application integration operates on a single (or few) object/row/line/message/event at a time, while data integration operates on multiple/batch of data at a time.

My simple analogy is this:

If two people are talking or discussing with each other they covey an idea and wait for a response - operating on a single object at a time. that is application integration
If you are reading a book and summarising a chapter in your own words - operating on a batch of data. that is data integration

go.reflect for a custom Print function

HM — Fri, 17 Dec 2021 02:29:49 +0000

Below, we create a function called Display that works like Println but even better: it shows the path traversed along with the value.

e.g.
Display([]string{"hello", "world"})
would print
root.0 = hello
root.1 = world

package main

import (
    "fmt"
    "reflect"
    "strconv"
)

func main() {
    Display("hi")
    Display([]string{"apple", "banana"})
    Display([...]string{"apple", "banana"})
    var i interface{} = 3
    Display(i)
    type astrct struct {
        Z string
    }
    type strct struct {
        A string
        B int
        astrct
    }
    Display(strct{"js", 1234, astrct{"nodejs"}})
    Display(&strct{"js", 1234, astrct{"nodejs"}})
    Display(map[string]int{"m1": 1, "m2": 2})
}

func Display(d interface{}) {
    fmt.Printf("-- Display for %T --\n", d)
    display("root", reflect.ValueOf(d))
}

func display(path string, v reflect.Value) {
    switch v.Kind() {
    case reflect.Slice, reflect.Array:
        for i := 0; i < v.Len(); i++ {
            display(fmt.Sprintf("%s.%v", path, i), v.Index(i))
        }
    case reflect.Struct:
        for i := 0; i < v.NumField(); i++ {
            display(fmt.Sprintf("%s.%s", path, v.Type().Field(i).Name), v.Field(i))
        }
    case reflect.Ptr:
        if v.IsNil() {
            fmt.Println("%s = nil", path)
        } else {
            display(fmt.Sprintf("*%s", path), v.Elem())
        }
    case reflect.Map:
        if v.IsNil() {
            fmt.Println("%s = nil", path)
        } else {
            for _, i := range v.MapKeys() {
                display(fmt.Sprintf("%s[%s]", path, i), v.MapIndex(i))
            }

        }
    case reflect.Interface:
        display(fmt.Sprintf("%s.value", path), v.Elem())

    default:
        fmt.Printf("%s = %s\n", path, formatToPrint(v))
    }
}

// formatToPrint formats a value without inspecting its internal structure.
func formatToPrint(v reflect.Value) string {
    switch k := v.Kind(); {
    case k == 0:
        return "invalid kind"
    case k == 1:
        return strconv.FormatBool(v.Bool())
    case k >= 2 && k <= 6:
        return strconv.FormatInt(v.Int(), 10)
    case k >= 7 && k <= 12:
        return strconv.FormatUint(v.Uint(), 10)
    case k >= 13 && k <= 14:
        return strconv.FormatFloat(v.Float(), 'E', -1, 64)
    case k >= 15 && k <= 16:
        return strconv.FormatComplex(v.Complex(), 'E', -1, 64)
    case k == 18 || k == 19 || k == 21 || k == 22 || k == 23:
        // reference types:
        // chan, func, map, ptr, Slice
        return "type=" + v.Type().String() + " 0x" + strconv.FormatUint(uint64(v.Pointer()), 16)
    case k == 24:
        // string
        return strconv.Quote(v.String())
    case k == 17 || k == 20 || k == 25:
        // aggregate types:
        // array, interface, struct
        return "type=" + v.Type().String()
    case k == 26:
        // unsafeptr
        return "unsafe ptr"
    default:
        return "N/A"
    }
}

Output from above code =

-- Display for string --
root = "hi"
-- Display for []string --
root.0 = "apple"
root.1 = "banana"
-- Display for [2]string --
root.0 = "apple"
root.1 = "banana"
-- Display for int --
root = 3
-- Display for main.strct --
root.A = "js"
root.B = 1234
root.astrct.Z = "nodejs"
-- Display for *main.strct --
*root.A = "js"
*root.B = 1234
*root.astrct.Z = "nodejs"
-- Display for map[string]int --
root[m1] = 1
root[m2] = 2

Default value in a struct

HM — Wed, 15 Dec 2021 10:06:09 +0000

/*
    set default values for a struct being Unmarshaled from json
*/
package main

import (
    "encoding/json"
    "fmt"
)

type Out struct {
    A string `json:"a"`
    B string `json:"b"`
    C string `json:"c"`
    D int    `json:"d"`
}

func main() {
    in := []byte(`{"a":"1"}`)
    out := Out{
        A: "defaultA",
        B: "defaultC",
        C: "defaultD",
        D: 99,
    }
    json.Unmarshal(in, &out)
    fmt.Printf("%+v\n ", out)
}

Handling JWT securely on your client

HM — Fri, 10 Apr 2020 12:26:42 +0000

This is a series of posts divided into the following parts:

Handling JWT securely on your client - Part-1
Handling JWT securely on your client - Part-2 [THIS POST]
Handling JWT securely on your client - Part-3 - not yet published
Handling JWT securely on your client - Part-4 - not yet published

Summary

Part-1 covers the main problem statement around jwt security in web-apps; presents a few options and evaluates them
Part-2 dives deep into overcoming limitations around the chosen option in Part-1 e.g. SSO, Silent Authentication/Refresh, etc.
Part-3 talks about non web-apps i.e. backend rest clients that don't run on web browsers e.g. postman
Part-4 talks about other values added flows such as jwt expiry, force logout etc.

Handling JWT securely on your client - Part-2

Quick recap

In the part 1 of this blog series, we established that in-memory storage is most secure way of storing jwt.

We also established that this approach brings about two limitations:

Limitation 1: SSO: Hampers the ability to implement SSO
Limitation 2: Session: Hampers user experience by forcing him/her to login on every tab/window A subset of Limitation 2 is that the user is forced to login when they close their browser and reopen it

More on the limitations

Limitation 1: SSO

Limitation 1 can only be solved with some sort of state management on the Authorization server. The server needs to retain information on all users who have logged in.

But this goes directly against the principles of using jwt, which are meant to be stateless.

Limitation 2: Session

Limitation 2 can only be solved with some sort of state management on the client browser side. The client needs to persist some information that is available across browser tabs and also across browser restarts.

But if you are thinking of persisting jwt (through localStorage or cookies), go to PART-1 of this series! I repeat - we will keep the jwt in-memory only

Overcoming these limitations

...continue reading here...

Handling JWT securely on your client

HM — Thu, 19 Mar 2020 11:33:24 +0000

This is a series of posts divided into the following parts:

Handling JWT securely on your client - Part-1
Handling JWT securely on your client - Part-2
Handling JWT securely on your client - Part-3
Handling JWT securely on your client - Part-4

Summary

Part-1 covers the main problem statement around jwt security in web-apps; presents a few options and evaluates them
Part-2 dives deep into overcoming limitations around the chosen option in Part-1 e.g. SSO, Silent Authentication/Refresh, etc.
Part-3 talks about non web-apps i.e. backend rest clients that don't run on web browsers e.g. postman
Part-4 talks about other values added flows such as jwt expiry, force logout etc.

Handling JWT securely on your client - Part-1

Assumptions

We will focus on Single Page Application (SPA) web-apps here
jwt here are treated as access tokens or sessions tokens
Our Use case:
- Our website is a SPA and hosted on app1.com
- The SPA allows login and logout at /login and /logout
- After logging in the SPA displays a button called "getData"
- Once the button is pressed, the client-side-js sends a request to /api/data to obtain some data

......continue here

Cryptography - to the point

HM — Fri, 13 Mar 2020 13:13:16 +0000

Of course! Cryptography is a very technical subject; it's difficult to understand the "how"

But there ubiquitous presence warrants to understand the "why & when"

Surprisingly, these questions aren't difficult to understand, so let's run through them quickly.

Some terms

Encryption and signing make use of keys
Private keys: are keys that are treated as secret and are usually used by a single entity
Public keys: are keys that are shared and available for anyone to use
Symmetric keys: where encryption and decryption is done using the same key
Asymmetric keys: where encryption and decryption is done using the separate keys belonging to a key-pair
Hashing makes use of a hashing function
Encoding (which is not cryptography) is merely changing how the data is represented e.g. ASCII, UTF-8, base64, base62, HEX etc.

Encryption, Signature & Hash

Encryption

Encrypt some data called X:
[X] --(public key)--> [Y]

Decrypt Y to obtain the data:
[Y] --(private key)--> [X]

To contunue reading, click https://mannharleen.github.io/2020-03-13-cryptography/

Creating an AWS lambda that acts as a proxy service

HM — Fri, 31 Jan 2020 10:48:55 +0000

The below code is limited to POST, but can be easily extended to any HTTP Method

const https = require('https');

const destinationHostname = 'someurl.io'
const destinationPath = '/somepath/dev/v1/hola'

exports.handler = async (event) => {
    event.headers = event.headers || {}
    console.log("event", event)
    let postData = event.body
    let body
    let statusCode
    let headers
    await new Promise((resolve, reject) => {
        let options = {
            hostname: destinationHostname,
            port: 443,
            path: destinationPath,
            method: 'POST',
            headers: event.headers,
            rejectUnauthorized: false
        }

        // add additional headers if required, in my case I am setting/resetting Auth header
        options.headers['Authorization'] = 'Basic XXXX'
        // most do:
        options.header["X-Forwarded-Host"] = options.header.Host
        delete options.header.Host // also delete the host before forwarding the request

        var req = https.request(options, (res) => {
            statusCode = res.statusCode 
            headers = res.headers 
            console.log('statusCode:', res.statusCode);
            console.log('headers:', res.headers);

            let chunks = [];
            res.on("data", function (chunk) {
                chunks.push(chunk);
            });
            res.on("end", function () {
                body = Buffer.concat(chunks).toString();
                console.log("RES BODY: ", body) // body.toString());
                resolve();
            });
        })
        req.on('error', (e) => {
            console.error(e);
        });
        req.write(postData)
        req.end()
    })    

    return {
        statusCode: statusCode || 200,
        headers: headers || {'content-type': 'application/json'},
        body: body
    };
};

Replace json values using a mapping json

HM — Thu, 30 Jan 2020 11:15:53 +0000

Problem statement

Given an input JSON like this

{
    "results": [
      {
        "id": 1,
        "relationx_id": "11"
      },
      {
        "id": 2,
        "relationx_id": "22"
      }
    ],
    "lookup_key": "relationx_id"
}

and a mapping JSON like this

{
    "11": "88",
    "22": "99"
}

Use the lookup_key to replace the value of the key as per the mapping JSON. The result should look like this

{
 "lookup_key": "relationx_id",
 "results": [
  {
   "id": 1,
   "relationx_id": "88"
  },
  {
   "id": 2,
   "relationx_id": "99"
  }
 ]
}

Solution

package main

import (
    "encoding/json"
    "fmt"
)

var inp string = `{
    "results": [
      {
        "id": 1,
        "relationx_id": "11"
      },
      {
        "id": 2,
        "relationx_id": "22"
      }
    ],
    "lookup_key": "relationx_id"
  }`

var mapping string = `{
    "11": "88",
    "22": "99"
}`

func main() {
    var inpJ map[string]interface{}
    json.Unmarshal([]byte(inp), &inpJ)
    // fmt.Printf("%+v\n", inpJ)

    var mappingJ map[string]string
    json.Unmarshal([]byte(mapping), &mappingJ)
    // fmt.Printf("%+v\n", mappingJ)

    lookupKey := inpJ["lookup_key"].(string)
    // fmt.Printf("%+v\n", lookupKey)

    for _, result := range inpJ["results"].([]interface{}) {
        resultMap := result.(map[string]interface{})
        for k, v := range resultMap {
            if k == lookupKey {
                resultMap[k] = mappingJ[v.(string)]
            }
        }
    }
    // fmt.Printf("%+v\n", inpJ)
    b, _ := json.MarshalIndent(inpJ, "", " ")
    fmt.Println(string(b))

}

To the point - generating random numbers in golang

HM — Mon, 20 Jan 2020 11:34:46 +0000

Generating random numbers

(integers for the sake of this post)

Usually

Most commonly, you would use the math/rand and the time pkg to seed the rand generator in go. This is shown below:

// code#1
package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    rand.Seed(time.Now().UnixNano())
    x := rand.Intn(5) // An int between [0,5)
    fmt.Println(x)
}

Unusually

Most of times, code#1 will do the job, BUT what if your randomness cannot depend on time alone.

Problem

As an example, suppose you want to create a function that must return two random numbers between 0 and n

Thought 1

You could math/rand.Perm(n) seeded with time.Now().UnixNano() to obtain a slice of n integers. And then pick the first two. Something like:

//code#2

func main() {
    rand.Seed(time.Now().UnixNano())
    x := rand.Perm(5)
    fmt.Println(x[0], x[1])
}

BUT, this is highly inefficient especially for large values of n.

Thought 2

Make use of the crypto/rand package to generate a truly random int.
Something like:

// code#3
package main

import (
    "fmt"
    "crypto/rand"
    "math/big"
)

func main() {
    x, _ := rand.Int(rand.Reader, big.NewInt(5))
    y, _ := rand.Int(rand.Reader, big.NewInt(5))
    fmt.Println(x, y)
}

That's all! Happy randomizing!

To the point: options as function for your APIs

HM — Mon, 20 Jan 2020 06:59:47 +0000

Problem

You have created a super performant csv reader that look like:

package awesomecsvreader

type csvReader struct{
    filename string
    delim string
    escape string
}

func (*csvReader) Read() {
    //...your awesome secret sauce
}

But whats missing it a simple API for users to use your module, that doesn;t look like this:

func NewCsvReader(filename string, delim string, escape string) {
    ....
} 
// ? what happens when new options are added like "separator". 
// red alert: api could break!

Solution

Thoughts:

One could use structs for options but that has the following demerits:

there is no good way of setting up default values for the options, unless the defaults are equal to zero values
an empty options struct needs to be passed by the user of the api

So, instead of using struct, use the power of functions with closures

Let's code

Commented inline for brevity.

// your module
package awesomecsvreader

import (
    "fmt"
)

// this is what my csvReader struct looks like
type csvReader struct{
    filename string
    delim string
    escape string
}

// I define a type that is a func that takes csvReader and sets the option
type option func(*csvReader)

// Take the delim string and return the option
func SetDelim(delim string) option{
    return func(cr *csvReader) {
        (*cr).delim = delim
    }
}

// Take the escape string and return the option
func SetEscape(escape string) option{
    return func(cr *csvReader) {
        cr.escape = escape
    }
}

// Constructor that takes required values like filename
//  and setters that are of type option
func NewCsvReader(filename string, setters ...option) *csvReader{

    // construct a csvReader with default values
    cr := csvReader{
        filename: filename,
        delim: "CRLB",
        escape: "ESC",
    }

    // change the default values as per those supplied by the user
    // by calling the option
    for _, setter := range setters {
        setter(&cr)
    }

    return &cr
}

// I am a user of your API
package main

func main() {

    //
    // create a csvReader with default options
    fmt.Println(NewCsvReader("file123"))

    //
    // create a csvReader with mix of default and custom options
    r1 := NewCsvReader("file123", SetDelim("XXX"))
    fmt.Println(r1)

    //
    // create a csvReader with all custom options
    r2 := NewCsvReader("file123", SetDelim("XXX"), SetEscape("YYY"))
    fmt.Println(r2)
}

// output
&{file123 CRLB ESC}
&{file123 XXX ESC}
&{file123 XXX YYY}

Good ref: https://dave.cheney.net/2014/10/17/functional-options-for-friendly-apis

To the point - http middleware in go with net/http Part - 2

HM — Wed, 15 Jan 2020 11:01:45 +0000

In the last post, we created an http middleware and propagated a value to signify if the user is logged in or not. The value was propagated using ResponseWriter.Header, that isn't really what we should do.

Instead, we should make use of the http.Request.Context

Note

We will not be using the "context" package directly
Since go v1.7, Context is part of the incoming http.Request object)

Very basics of http.Request.Context:

// Given a request "r"

// context values are immutable, 
// so, creating a new context from existing context:
newContext := context.WithValue(r.Context(), key, <someValue>)

// a context can be attached to the request only upon request creation,
// so, create a new request using the next context:
r = r.WithContext(newContext)

// reading the value off the context in a downstream middleware
readValue := r.Context().Value(key).(string)

// some extra stuff to note: (ref https://golang.org/pkg/context/#WithValue)
// so, create out own type for the context key and assign name for the key
type contextKey string
var key contextKey = "loggedIn"

Note: The way contexts work, they are only propagated downstream. i.e. A middleware sitting before another middleware creating a context wont be able to access the context

Code it!

With the above knowledge we can make the changes!

The changes are all marked with the comment prefixed with "CHANGE: "

package main

import (
    "context"
    "fmt"
    "log"
    "math/rand"
    "net/http"
    "time"
)

var mux *http.ServeMux = http.NewServeMux()

func main() {
    mux.HandleFunc("/", loggedInMw(lowMw(userInfo))) //lowMw(loggedInMw(userInfo)))
    fmt.Println("server running on 8080")
    log.Fatal(http.ListenAndServe(":8080", mux))
}

// check header "loggedIn"
func userInfo(w http.ResponseWriter, r *http.Request) {
    // w.Write([]byte(w.Header().Get("loggedIn"))) // CHANGE: replace this line with the following
    w.Write([]byte(r.Context().Value(key).(string)))
}

// log the req and response after the final handler has been called
func lowMw(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // start middleware logic
        t := time.Now()
        next(w, r)
        fmt.Printf(`[%v] {"r.Method": "%s", "r.URL.Path": "%s", "status": "%v", "timeTakenµs":"%v", "loggedIn": "%s"}
`, t.UTC(), r.Method, r.URL.Path, 200, time.Since(t).Nanoseconds(), r.Context().Value(key)) // CHANGE: replaced w.Header().Get("loggedIn")
    }
}

// check if user is logged or not and set a header called "loggedIn" for next handlerFunc to read from
func loggedInMw(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // start middleware logic
        //
        // dummy process of setting loggedIn = true
        rand.Seed(time.Now().UnixNano())
        temp := rand.Intn(2)
        var loggedIn string = "no"
        if temp == 0 {
            loggedIn = "yes"
        }
        // end of dummy process
        //

        // w.Header().Set("loggedIn", loggedIn) // CHANGE: replace this line with the following lines

        newContext := context.WithValue(r.Context(), key, loggedIn)
        r = r.WithContext(newContext) // even this works: r = r.Clone(newContext); Q. exercise: explore the difference!

        // end of middleware logic
        next(w, r)
    }
}

// CHANGE: add the following lines
// create out own type for the context key and assign name for the key
type contextKey string
var key contextKey = "loggedIn"

Output

Checkout the "loggedIn" in the log below! We did!

[2020-01-15 00:17:20.1845556 +0000 UTC] {"r.Method": "GET", "r.URL.Path": "/", "status": "200", "timeTakenµs":"0", "loggedIn": "yes"}
[2020-01-15 00:17:20.8007946 +0000 UTC] {"r.Method": "GET", "r.URL.Path": "/", "status": "200", "timeTakenµs":"0", "loggedIn": "no"}
[2020-01-15 00:17:21.320177 +0000 UTC] {"r.Method": "GET", "r.URL.Path": "/", "status": "200", "timeTakenµs":"0", "loggedIn": "yes"}
[2020-01-15 00:17:23.6705213 +0000 UTC] {"r.Method": "GET", "r.URL.Path": "/", "status": "200", "timeTakenµs":"0", "loggedIn": "no"}

To the point - http middleware in go with net/http Part - 1

HM — Tue, 14 Jan 2020 05:29:04 +0000

What the hell middleware!

If you are programmer you have probably heard one of the two terms - "middleware" or "decorator"
They both achieve the same thing!

A pattern that allows adding new behaviors to objects/functions dynamically by placing them inside special wrapper objects/functions. This allows wrapping countless number of times since both input and output follow the same interface.

Requirement:

Create two middlewares:

logMw: for logging req and response
loggedInMw: for verifying that a user is logged in

Create one handler:

"/me" shows basic user information if not logged in. But shows more info if user is logged in

Thinking:

I should be able to use the middleware like this:

mux.HandleFunc("/", logMw(loggedInMw(userInfo)))

where userInfo is my http.HandlerFunc
and lowMw and loggedInMw are the middlewares

More thinking:

A middleware then is a function that accepts and returns a HandlerFunc, thus enabling chaining

func(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        //middleware logic
        .... // can operate on w and r

        //call next in the end
        next(w, r)
    }
}

Code it!

From now on see my comments inline.

Note: The pattern to add a header called "loggedIn" is not the right thing to do . We will look at how to make it right, but for this example bear with me.

package main

import (
    "fmt"
    "log"
    "math/rand"
    "net/http"
    "time"
)

var mux *http.ServeMux = http.NewServeMux()

func main() {
    mux.HandleFunc("/", lowMw(loggedInMw(userInfo)))
    fmt.Println("server running on 8080")
    log.Fatal(http.ListenAndServe(":8080", mux))

}

// check header "loggedIn"
func userInfo(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte(w.Header().Get("loggedIn")))
}

// log the req and response after the final handler has been called
func lowMw(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // start middleware logic
        t := time.Now()
        next(w, r)
        fmt.Printf(`[%v] {"r.Method": "%s", "r.URL.Path": "%s", "status": "%v", "timeTakenµs":"%v", "loggedIn": "%s"}
`, t.UTC(), r.Method, r.URL.Path, 200, time.Since(t).Nanoseconds(), w.Header().Get("loggedIn"))
    }
}

// check if user is logged or not and set a header called "loggedIn" for next handlerFunc to read from
func loggedInMw(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // start middleware logic
        //
        // dummy process of setting loggedIn = true
        rand.Seed(time.Now().UnixNano())
        temp := rand.Intn(2)
        var loggedIn string = "no"
        if temp == 0 {
            loggedIn = "yes"
        } 
        // end of dummy process
        //
        w.Header().Set("loggedIn", loggedIn)
        // end of middleware logic
        next(w, r)
    }
}

Output

Checkout the "loggedIn" in the log below! We did!

[2020-01-14 03:50:39.7792098 +0000 UTC] {"r.Method": "GET", "r.URL.Path": "/", "status": "200", "timeTakenµs":"0", "loggedIn": "yes"}
[2020-01-14 03:50:39.9446553 +0000 UTC] {"r.Method": "GET", "r.URL.Path": "/", "status": "200", "timeTakenµs":"0", "loggedIn": "no"}
[2020-01-14 03:50:40.1101016 +0000 UTC] {"r.Method": "GET", "r.URL.Path": "/", "status": "200", "timeTakenµs":"0", "loggedIn": "yes"}
[2020-01-14 03:50:40.2615089 +0000 UTC] {"r.Method": "GET", "r.URL.Path": "/", "status": "200", "timeTakenµs":"0", "loggedIn": "yes"}
[2020-01-14 03:50:40.4339753 +0000 UTC] {"r.Method": "GET", "r.URL.Path": "/", "status": "200", "timeTakenµs":"0", "loggedIn": "yes"}
[2020-01-14 03:50:40.5863852 +0000 UTC] {"r.Method": "GET", "r.URL.Path": "/", "status": "200", "timeTakenµs":"0", "loggedIn": "yes"}

DEV Community: HM

Data vs Application Integration

go.reflect for a custom Print function

Default value in a struct

Handling JWT securely on your client

Summary

Handling JWT securely on your client - Part-2

Quick recap

More on the limitations

Limitation 1: SSO

Limitation 2: Session

Overcoming these limitations

Handling JWT securely on your client

Summary

Handling JWT securely on your client - Part-1

Assumptions

Cryptography - to the point

Some terms

Encryption, Signature & Hash

Encryption

Creating an AWS lambda that acts as a proxy service

The below code is limited to POST, but can be easily extended to any HTTP Method

Replace json values using a mapping json

Problem statement

Given an input JSON like this

and a mapping JSON like this

Use the lookup_key to replace the value of the key as per the mapping JSON. The result should look like this

Solution

To the point - generating random numbers in golang

Generating random numbers

Usually

Unusually

Problem

Thought 1

Thought 2

To the point: options as function for your APIs

Problem

Solution

Thoughts:

Let's code

To the point - http middleware in go with net/http Part - 2

Note

Very basics of http.Request.Context:

Code it!

Output

You may like to read the series:

Further reading:

To the point - http middleware in go with net/http Part - 1

What the hell middleware!

Requirement:

Thinking:

More thinking:

Code it!

Output

You may like to read the series: