Golang logmessage.LogMessage類代碼示例

func extractLogContent(logMsg *logmessage.LogMessage, logHeader string) (logContent string) {
	msgText := string(logMsg.GetMessage())
	reg, err := regexp.Compile("[\n\r]+$")
	if err == nil {
		msgText = reg.ReplaceAllString(msgText, "")
	}

	msgLines := strings.Split(msgText, "\n")
	padding := strings.Repeat(" ", len(logHeader))
	coloringFunc := terminal.LogStdoutColor
	logType := "OUT"

	if logMsg.GetMessageType() == logmessage.LogMessage_ERR {
		coloringFunc = terminal.LogStderrColor
		logType = "ERR"
	}

	logContent = fmt.Sprintf("%s %s", logType, msgLines[0])
	for _, msgLine := range msgLines[1:] {
		logContent = fmt.Sprintf("%s\n%s%s", logContent, padding, msgLine)
	}
	logContent = coloringFunc(logContent)

	return
}

func (e *LoggregatorEmitter) EmitLogMessage(logMessage *logmessage.LogMessage) {
	messages := splitMessage(string(logMessage.GetMessage()))

	for _, message := range messages {
		if isEmpty(message) {
			continue
		}

		if len(message) > MAX_MESSAGE_BYTE_SIZE {
			logMessage.Message = append([]byte(message)[0:TRUNCATED_OFFSET], TRUNCATED_BYTES...)
		} else {
			logMessage.Message = []byte(message)
		}
		if e.sharedSecret == "" {
			marshalledLogMessage, err := proto.Marshal(logMessage)
			if err != nil {
				e.logger.Errorf("Error marshalling message: %s", err)
				return
			}
			e.LoggregatorClient.Send(marshalledLogMessage)
		} else {
			logEnvelope, err := e.newLogEnvelope(*logMessage.AppId, logMessage)
			if err != nil {
				e.logger.Errorf("Error creating envelope: %s", err)
				return
			}
			marshalledLogEnvelope, err := proto.Marshal(logEnvelope)
			if err != nil {
				e.logger.Errorf("Error marshalling envelope: %s", err)
				return
			}
			e.LoggregatorClient.Send(marshalledLogEnvelope)
		}
	}
}

func simpleLogMessageOutput(logMsg *logmessage.LogMessage) (msgText string) {
	msgText = string(logMsg.GetMessage())
	reg, err := regexp.Compile("[\n\r]+$")
	if err != nil {
		return
	}
	msgText = reg.ReplaceAllString(msgText, "")
	return
}

func createMessage(t *testing.T, protoMsg *logmessage.LogMessage, sourceName *string, msgType *logmessage.LogMessage_MessageType) (msg *logmessage.Message) {
	protoMsg.SourceName = sourceName
	protoMsg.MessageType = msgType

	data, err := proto.Marshal(protoMsg)
	assert.NoError(t, err)

	msg, err = logmessage.ParseMessage(data)
	assert.NoError(t, err)

	return
}

func createMessage(protoMsg *logmessage.LogMessage, sourceName *string, msgType *logmessage.LogMessage_MessageType) (msg *logmessage.Message) {
	protoMsg.SourceName = sourceName
	protoMsg.MessageType = msgType

	data, err := proto.Marshal(protoMsg)
	Expect(err).NotTo(HaveOccurred())

	msg, err = logmessage.ParseMessage(data)
	Expect(err).NotTo(HaveOccurred())

	return
}

// ParseLogMessages is a modified version of httpRecent.
// https://github.com/cloudfoundry/loggregator_consumer/blob/89d7fe237afae1e8222554359ec03b72c8466d10/consumer.go#L145
// Also, when using their Recent function, we would get unauthorized errors. If we make the request ourselves, it works.
// TODO eventually figure out the cause of the unauthorized errors
func (c *LogContext) ParseLogMessages(body *io.ReadCloser, contentType string) (*bytes.Buffer, error) {
	_, params, err := mime.ParseMediaType(contentType)
	if err != nil {
		return nil, err
	}

	var msg logmessage.LogMessage
	reader := multipart.NewReader(*body, params["boundary"])
	var buffer bytes.Buffer
	var messages bytes.Buffer
	firstNotInserted := true
	messages.WriteRune('[')
	for part, loopErr := reader.NextPart(); loopErr == nil; part, loopErr = reader.NextPart() {
		// Skip putting a comma if we haven't put the first element in there yet.
		if !firstNotInserted {
			messages.WriteRune(',')
		} else {
			firstNotInserted = false
		}

		// Clear out temporary buffer.
		buffer.Reset()

		msg = logmessage.LogMessage{}
		// Read raw bytes.
		_, err := buffer.ReadFrom(part)
		if err != nil {
			break
		}
		// Try to unmarshal the bytes into a LogMessage struct.
		proto.Unmarshal(buffer.Bytes(), &msg)
		// Marshal the data into json with only the Message.
		json, err := json.Marshal(struct {
			Message string `json:"message"`
		}{
			Message: string(msg.GetMessage()),
		})
		// Write it to our buffer.
		messages.Write(json)
		part.Close()
	}
	messages.WriteRune(']')
	buffer.Reset()
	return &messages, nil
}

func ExtractLogContent(logMsg *logmessage.LogMessage, logHeader string) (logContent string) {
	msgText := string(logMsg.GetMessage())
	msgText = newLinesPattern.ReplaceAllString(msgText, "")

	msgLines := strings.Split(msgText, "\n")
	padding := strings.Repeat(" ", utf8.RuneCountInString(logHeader))
	coloringFunc := terminal.LogStdoutColor
	logType := "OUT"

	if logMsg.GetMessageType() == logmessage.LogMessage_ERR {
		coloringFunc = terminal.LogStderrColor
		logType = "ERR"
	}

	logContent = fmt.Sprintf("%s %s", logType, msgLines[0])
	for _, msgLine := range msgLines[1:] {
		logContent = fmt.Sprintf("%s\n%s%s", logContent, padding, msgLine)
	}
	logContent = coloringFunc(logContent)

	return
}

func getLoggregatorMsgString(message *logmessage.LogMessage) string {
	return string(message.GetMessage())
}

	Context("Streaming", func() {
		It("delivers legacy format messages at legacy endpoint", func() {
			legacy_consumer := loggregator_consumer.New(legacyEndpoint, &tls.Config{}, nil)
			messages, err := legacy_consumer.Tail(APP_ID, AUTH_TOKEN)
			Expect(err).NotTo(HaveOccurred())
			var request *http.Request
			Eventually(fakeDoppler.TrafficControllerConnected, 10).Should(Receive(&request))

			Expect(request.URL.Path).To(Equal("/apps/1234/stream"))

			currentTime := time.Now().UnixNano()
			dropsondeMessage := makeDropsondeMessage("Make me Legacy Format", APP_ID, currentTime)
			fakeDoppler.SendLogMessage(dropsondeMessage)

			var receivedMessage *logmessage.LogMessage
			Eventually(messages).Should(Receive(&receivedMessage))

			Expect(receivedMessage.GetMessage()).To(BeEquivalentTo("Make me Legacy Format"))
			Expect(receivedMessage.GetAppId()).To(Equal(APP_ID))
			Expect(receivedMessage.GetTimestamp()).To(Equal(currentTime))

			legacy_consumer.Close()
		})
	})

	Context("Recent", func() {
		It("returns a multi-part HTTP response with all recent messages", func() {
			const messageLength = 5
			expectedMessages := make([][]byte, messageLength)

			LogMessage: &events.LogMessage{
				Message:        message,
				MessageType:    events.LogMessage_OUT.Enum(),
				Timestamp:      proto.Int64(1234),
				AppId:          proto.String("AppId"),
				SourceType:     proto.String("SRC"),
				SourceInstance: proto.String("0"),
			},
		}

		bytes, _ := proto.Marshal(envelope)
		msg, err := marshaller.TranslateDropsondeToLegacyLogMessage(bytes)

		Expect(err).To(BeNil())

		var legacyMessage logmessage.LogMessage
		proto.Unmarshal(msg, &legacyMessage)
		Expect(legacyMessage.GetMessage()).To(Equal(message))
		Expect(legacyMessage.GetAppId()).To(Equal("AppId"))
		Expect(legacyMessage.GetSourceName()).To(Equal("SRC"))
		Expect(legacyMessage.GetSourceId()).To(Equal("0"))
		Expect(legacyMessage.GetTimestamp()).To(BeNumerically("==", 1234))
	})

	It("returns an error if it fails to unmarshall the envelope", func() {
		junk := []byte{1, 2, 3}

		msg, err := marshaller.TranslateDropsondeToLegacyLogMessage(junk)

		Expect(msg).To(BeNil())
		Expect(err.Error()).To(ContainSubstring("Unable to unmarshal"))