Q:

Arduino String concatenation Serial.println() doesn't work

I'm trying to read pass data of some text to server by first sending whole text to a function which finds its length and uses AT+CIPSEND=length comes here to open a TCP port later on. Everything was working fine before I add some additional info to my response data. I'm suspecting of char limits but couldn't find a reason even though debugging few hours.
Serial.println() doesn't show any output and string concatenation isn't healthy as it seems. The problem is that text is not being passed therefore CIPSEND doesn't work. Corresponding code section and its output shown below.
void sendHTTPResponse(int connectionId, String content) {
  Serial.println("SENDHTTPRESPONSE1: " + content);

  // build HTTP response
  String httpResponse;
  String httpHeader;
  // HTTP Header
  httpHeader = "HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=UTF-8\r\n";
  httpHeader += "Content-Length: ";
  httpHeader += content.length();
  httpHeader += "\r\n";
  httpHeader += "Connection: close\r\n\r\n";
  Serial.println("SENDHTTPRESPONSE2: " + httpHeader);
  httpResponse = httpHeader + content + " "; // There is a bug in this code: the last character of "content" is not sent, I cheated by adding this extra space
  Serial.println("HTTPRESPONSE3: " + httpResponse);
  sendCIPData(connectionId, httpResponse);
}

And serial monitor output. HTTPRESPONSE3 seems to be somehow empty?
SENDHTTPRESPONSE1: {"data":[{"id":"100"}]}{"data":[{"id":"100"}]}{"data":[{"id":"100"}]}{"data":[{"id":"100"}]}
SENDHTTPRESPONSE2: HTTP/1.1 200 OK
Content-Type: text/html; charset=UTF-8
Content-Length: 92
Connection: close

DATA LENGTH: 

======================================================
Executing command: AT+CIPSEND=0,0

HTTP/1.1
CoAT+CIPSEND=0,0

Thanks in advance.

A:

This answer doesn't actually solve your problem.
To my excuse, I don't have the Arduino with me, so I can't reproduce your issue. :)
However, since you are into "string concatenation" style, I think you might benefit from using the source code posted here (provided that your project has room for it).
It's a small c++-style wrapper around the print library that I wrote two years ago. It will let you write stuff like this:
io::cout << "This is a beautiful message!\n"
         << io::setprecision(3) << some_float << "\n"
         << io::setbase(BIN) << some_int << io::endl;

By default the library provides io::cout which prints through usual Serial. You can hook this library up with any object implementing the Print interface, e.g. Serial and Software Serial.
The difference with what you are doing now is that by using the "<<" you'll get the same clean code-style as with "+", but you won't need to create a temporary String. Everything is immediately laid off to the output buffer to be printed out. As a result, you shouldn't incur in the same issue that you are experiencing right now. In other words, this does what @Olaf suggested in the comments, but in a fancy way. ;)
Note: You probably need to fix the includes in the test-iocout.ino file to fit your project.

cout.h
#ifndef __COUT_H__
#define __COUT_H__

#include <Arduino.h>

namespace io {

/**
 * marker to end a message
 * (prints newline)
 */
struct Endl {};
const Endl endl = Endl();

/**
 * marker to modify way in which numbers are
 * printed on output stream
 */
struct setbase {
    uint8_t base;
    setbase(uint8_t v = DEC): base(v) {}
};

/**
 * marker to modify number of digits of doubles
 * printed on output stream
 */
struct setprecision {
    uint8_t precision;
    setprecision(uint8_t v = 2): precision(v) {}
};

/**
 * class out
 *
 * Provides a C++-like interface for printing stuff on
 * an output Stream, e.g. Serial, SoftwareSerial objects
 * Assumes a separated Stream initialization handling
 */
class out {
public:

    out(Print& print = Serial, uint8_t fmt = DEC, uint8_t dgt = 2);
    out(const out& other);
    out& operator =(const out& other);
    virtual ~out();

    inline out& operator<<(const String& msg)
    {
        __print.print(msg);
        return *this;
    };

    inline out& operator<<(const char msg[])
    {
        __print.print(msg);
        return *this;
    };

    inline out& operator<<(char c)
    {
        __print.print(c);
        return *this;
    };

    inline out& operator<<(unsigned char uc)
    {
        __print.print(uc, __base);
        return *this;
    };

    inline out& operator<<(int n)
    {
        __print.print(n, __base);
        return *this;
    };

    inline out& operator<<(unsigned int un)
    {
        __print.print(un, __base);
        return *this;
    };

    inline out& operator<<(long l)
    {
        __print.print(l, __base);
        return *this;
    };

    inline out& operator<<(unsigned long ul)
    {
        __print.print(ul, __base);
        return *this;
    };

    inline out& operator<<(double d)
    {
        __print.print(d, __precision);
        return *this;
    };

    inline out& operator<<(const __FlashStringHelper *fsh)
    {
        __print.print(fsh);
        return *this;
    };

    inline out& operator<<(const Printable& pr)
    {
        __print.print(pr);
        return *this;
    };

    inline out& operator<<(const Endl& el)
    {
        __print.println("");
        __base = DEC;
        __precision = 2;
        return *this;
    };

    inline out& operator<<(const setbase& p)
    {
        __base = p.base;
        return *this;
    };

    inline out& operator<<(const setprecision& p)
    {
        __precision = p.precision;
        return *this;
    };

    inline int getWriteError()
    {
        return __print.getWriteError();
    };

    inline void clearWriteError()
    {
        __print.clearWriteError();
    };

private:
    Print& __print;
    ///< output stream, must be separately initalized
    uint8_t __base;
    ///< base with which print numerical data
    uint8_t __precision;
    ///< number of fractional digits of float/double values
};

/**
 * Global io::cout object
 */
extern out cout;

} /* namespace io */

#endif

cout.cpp
#include "cout.h"

namespace io {

out cout;

out::out(Print& print, uint8_t fmt, uint8_t dgt):
    __print(print), __base(fmt),
    __precision(dgt)
{
    // nothing to do
};

out::out(const out& other):
    __print(other.__print),
    __base(other.__base),
    __precision(other.__precision)
{
    // nothing to do
};

out& out::operator =(const out& other)
{
    if (this != &other) {
        __print = other.__print;
        __base = other.__base;
        __precision = other.__precision;
    }
    return *this;
};

out::~out()
{
    // nothing to do
};

} /* namespace io */

test-iocout.ino
#include <Arduino.h>
#include "src/cout.h"

/******************************************************************************/
/*** PINS & GLOBALS                                                         ***/
/******************************************************************************/

const uint32_t SERIAL_BAUDRATE = 4800;

/******************************************************************************/
/*** RESOURCES                                                              ***/
/******************************************************************************/

/******************************************************************************/
/*** MAIN                                                                   ***/
/******************************************************************************/

/**
 * setup:
 * sets up the resources used within the arduino
 */
void setup()
{
    /* Initialize serial */
    Serial.begin(SERIAL_BAUDRATE);
    while (!Serial)
    {
        /* Needed by Arduino Leonardo */
    }

    /* new c++-like access to serial! */
    io::cout << "##### Arduino Station #####\n\n"
            << "- io::cout test 1.0" << io::endl;
}

/**
 * loop:
 *
 */
void loop()
{
    /* compute deltaTime */
    uint32_t curr_time = millis();
    static uint32_t start_time = curr_time; // note: initialized once!
    uint32_t deltaTime = curr_time - start_time;
    start_time = curr_time;

    io::cout << "\n> Last loop duration was: ";

    io::cout << io::setprecision(3)
            << deltaTime/1000.0f
            << " s." << io::endl;

    io::cout << "> 1025 in binary is: "
            << io::setbase(BIN)
            << 1025 << io::endl;

    delay(10000);
}

