logging

README

Using the logging client

package main

import (
        "fmt"
        "time"
        "github.com/philips-software/go-hsdp-api/logging"
)

func main() {
        client, err := logging.NewClient(http.DefaultClient, logging.Config{
                SharedKey:    "YourSharedKey",
                SharedSecret: "YourSharedSecret",
                BaseURL:      "https://logingestor-xxx.foo.com",
                ProductKey:   "YourProductKey",
        })
        var logResource = logging.Resource{
           ID: "856b1142-6df5-4c84-b11d-da3f0a794e84",
           EventID: "1",
           Category: "ApplicationLog",
           Component: "TestApp",
           TransactionID: "1f12f95c-77a0-48da-835d-e95aa116198f", // traceability
           ServiceName: "TestApp",
           ApplicationInstance: "7248e79e-ba0b-4d0e-82a9-fb7a47d26c23",
           OriginatingUser: "729e83bb-ce7d-4052-92f8-077a376d774c",
           Severity: "Info",
           LogTime: time.Now().Format("2006-01-02T15:04:05.000Z07:00")
           LogData.Message: "Test log message",
        }
        _, err := client.StoreResource([]logging.Resource{ logResource }, 1)
        if err != nil {
            fmt.Printf("Batch flushing failed: %v\n", err)
        }
}

Issues

• If you have an issue: report it on the issue tracker

Author

Andy Lo-A-Foe (andy.lo-a-foe@philips.com)

License

License is MIT. See LICENSE file

Documentation

Overview

Package logging provides support for HSDP Logging services

Index

• Variables
• func CheckResponse(r *http.Response) error
• type Bundle
• type Client
  • func NewClient(httpClient *http.Client, config Config) (*Client, error)
  • func (c *Client) Do(req *http.Request, v interface{}) (*Response, error)
  • func (c *Client) StoreResources(msgs []Resource, count int) (*Response, error)
• type Config
  • func (c *Config) Valid() (bool, error)
• type CustomIndexBody
• type Element
• type ErrorResponse
  • func (e *ErrorResponse) Error() string
• type LogData
• type Resource
  • func (r *Resource) Valid() bool
• type Response
• type Storer

Variables

var (
	// LogTimeFormat is the log time format to use
	LogTimeFormat = "2006-01-02T15:04:05.000Z07:00"

	ErrNothingToPost       = errors.New("nothing to post")
	ErrMissingSharedKey    = errors.New("missing shared key")
	ErrMissingSharedSecret = errors.New("missing shared secret")
	ErrMissingBaseURL      = errors.New("missing base URL")
	ErrMissingProductKey   = errors.New("missing ProductKey")
)

Functions

func CheckResponse

func CheckResponse(r *http.Response) error

CheckResponse checks the API response for errors, and returns them if present.

Types

type Bundle

type Bundle struct {
	ResourceType string    `json:"resourceType"`
	Type         string    `json:"type"`
	Total        int       `json:"total"`
	ProductKey   string    `json:"productKey,omitempty"`
	Entry        []Element `json:"entry"`
}

Bundle is a FHIR bundle resource There is just enough there to create the logging payload

type Client

type Client struct {
	// contains filtered or unexported fields
}

Client holds the client state

func NewClient

func NewClient(httpClient *http.Client, config Config) (*Client, error)

NewClient returns an instance of the logger client with the given Config

func (*Client) Do

func (c *Client) Do(req *http.Request, v interface{}) (*Response, error)

Do sends an API request and returns the API response. The API response is JSON decoded and stored in the value pointed to by v, or returned as an error if an API error has occurred. If v implements the io.Writer interface, the raw response body will be written to v, without attempting to first decode it.

func (*Client) StoreResources

func (c *Client) StoreResources(msgs []Resource, count int) (*Response, error)

StoreResources posts one or more log messages

type Config

type Config struct {
	SharedKey    string
	SharedSecret string
	BaseURL      string
	ProductKey   string
	Debug        bool
}

Config the client

func (*Config) Valid

func (c *Config) Valid() (bool, error)

Valid returns if all required config fields are present, false otherwise

type CustomIndexBody

type CustomIndexBody []struct {
	Fieldname string `json:"fieldname"`
	Fieldtype string `json:"fieldtype"`
}

CustomIndexBody describes the custom index request payload

type Element

type Element struct {
	Resource Resource `json:"resource"`
}

Element is a FHIR element resource

type ErrorResponse

type ErrorResponse struct {
	Response *http.Response
	Message  string
}

ErrorResponse holds an error response from the server

func (*ErrorResponse) Error

func (e *ErrorResponse) Error() string

type LogData

type LogData struct {
	Message string `json:"message"`
}

LogData is the payload of a log message

type Resource

type Resource struct {
	ResourceType        string          `json:"resourceType"`        // LogEvent
	ID                  string          `json:"id"`                  // 7f4c85a8-e472-479f-b772-2916353d02a4
	ApplicationName     string          `json:"applicationName"`     // OPS
	EventID             string          `json:"eventId"`             // 110114
	Category            string          `json:"category"`            // TRACELOG
	Component           string          `json:"component"`           // "TEST"
	TransactionID       string          `json:"transactionId"`       // 2abd7355-cbdd-43e1-b32a-43ec19cd98f0
	ServiceName         string          `json:"serviceName"`         // OPS
	ApplicationInstance string          `json:"applicationInstance"` // INST-00002
	ApplicationVersion  string          `json:"applicationVersion"`  // 1.0.0
	OriginatingUser     string          `json:"originatingUser"`     // SomeUser
	ServerName          string          `json:"serverName"`          // app.example.com
	LogTime             string          `json:"logTime"`             // 2017-01-31T08:00:00Z
	Severity            string          `json:"severity"`            // INFO
	LogData             LogData         `json:"logData"`             // Log data
	Custom              json.RawMessage `json:"custom,omitempty"`    // Custom log fields
}

Resource is a logging resource

func (*Resource) Valid

func (r *Resource) Valid() bool

Valid returns true if a resource is valid according to HSDP rules, false otherwise

type Response

type Response struct {
	*http.Response
	Message string
	Failed  []Resource
}

Response holds a LogEvent response

type Storer

type Storer interface {
	StoreResources(msgs []Resource, count int) (*Response, error)
}

Storer defines the store operations for logging